//define(['js/_services/module.js','loadingoverlay'],function(services){
define(['angular','loadingoverlay'],function(angular){
    'use strict';
	//定义数据组件
    /*
     * v0.0.1
	   * 增加creater后台调用；
	   * 整理newData和insert函数；
	   * 开始启用版本管理。
     */
    /*
     * v0.0.2
     * 2018-11-16
	 *将ajax转换为异步操作；
	 * 1、refreshData功能已经完成
	 * 2、saveData功能已经修改完成
	 * 3、removeData删除功能已经完成
	 * 4、newData新增功能改造完成 2018-11-17
	 * 接下来改造后台返回值的问题，将改造为标准API的json的返回格式
	 * {"code":0,"msg":"success","data":obj}
     */
    /*
     * v0.0.3
     * 2019-08-12
     * 要求必须设置httpUrl属性值，否则无法通过。
	 * 接下来改造后台返回值的问题，将改造为标准API的json的返回格式（已经改造完成，未记录何时do it）
	 * {"code":0,"msg":"success","data":obj}
     */
    /*
     * 2020-01-17
     * 去掉列定义项defCols，修改了插入行和查询函数，初始化行的函数，获取列类型的函数
     * 修改监视器函数，将输入后遍历每一行的列改为只遍历当前行的列来判断是否有更改
     */
    /*
     * 2020-05-07
     * 启用树形函数调用tableToTreeJson
     * 以为例groupSPFL为例
     * 由于工程量太大，暂时搁置
     */
    
    /*
     * 2020-06-17
     * 将树形数据的子节点数据加载从展开动作expand()调整到setCurrentIndex()函数中，
     * 以便于支持在this.treeOption.rootFilter!=''的情况下，新增一行时sortNo正确。
     */
    
//    var bizDataService = function(){
    var bizDataService = function(){
//    var bizDataService = function($rootScope){
    	
    	function BizData(options){
    		var _self = this;
    		
    		this.name = options.name;
    		this.concept = options.concept;
    		this.url = options.url;
    		console.log('BizData.concept-->', options.concept);
//    		console.log('BizData.url-->', options.url);
    		console.log('输入BizData.httpUrl-->', options.httpUrl);
    		if(options.httpUrl==undefined){
    			/*
				var pathName=window.document.location.pathname;
				var projectName=pathName.substring(0,pathName.substr(1).indexOf('/')+1);//获取带"/"的项目名，如：/uimcardprj
				this.httpUrl = projectName;
				*/
    			alert('服务路径未设置，可能引起bug。');
    			this.httpUrl = '';
    		}else{
        		this.httpUrl = options.httpUrl;
    		}
    		console.log('最终httpUrl-->', this.httpUrl);
	   		if(options.container){
    			this.container = options.container;
    		}
	   		
	   		this.userdata = {
				idColumnDefine: "fID"
				,idColumnName: "fID"
				,idColumnType: "String"
				,model: ""
//				,relationAlias: "fAddress,fContent,fCreateTime,fPhoneNumber,fSum,fUserID,fUserName"
//				,relationTypes: "String,String,DateTime,String,Float,String,String"
				,"sys.count":0
				,"sys.offset":0
				,updateMode: "whereVersion"
//				,relations: "fAddress,fContent,fCreateTime,fPhoneNumber,fSum,fUserID,fUserName"
				,changed:0
				,recordState:'none'
				,validColumns: "" //"billType,preChar"
			};
//			this["@type"] = "table";
			this.rows = new Array();
			this.deleterows= new Array();
			this.defCols = null;
			this.autoload=true;
			this.autonew=false;
			this.currentIndex=null;
			this.historyIndex=null;
			this.currentID=null;
			//this.tableStyle={'background-color':'white'}
			this.isTree=true;
			this.treeOption={
				parentRelation:'fParent'
				,nodeKindRelation:'nodeKind'
				,virtualRoot:''
				,nodeLevelRelation:''
				,nodeSortRelation:''
				,rootFilter:''
				,pathRelation:''
			};
			this.master={"data":"","relation":""};
			this.masterData=null;
			this.slaveDatas=[];
			this.deleteConfirm = true;
			this.directDeleteMode = false;
			this.orderBy = null;

			this.aggregateColumns = null;
			this.aggregate = null;

			//分页
			//在前端设定每页显示行数，在模版中初始化
			this.pageSizes = [
			                {id:10,name:'10行'}
			                ,{id:12,name:'12行'}
			                ,{id:15,name:'15行'}
			                ,{id:20,name:'20行'}
			                ,{id:50,name:'50行'}
			                ,{id:500,name:'500行'}
			                /*,{id:-1,name:'全部'}*/
			                ];
			
			//pageSizes中的当前值
			this.limit = -1; //this.pageSizes[0].id;
			this.totalPage = 1; //总页数
			this.currentPage = 1;
			this.pages = []; //翻页按钮集合
			this.total = 0; //总行数
			this.offset = 0; //行偏移(前端计算，带入后端)
			this.search = null; //模糊查询
			this.filters = [];//JSON格式[{"name":"filter1","filter":"sss"},{"name":"filter2","filter":"sss2"}];
			this.filterRelations = null; //模糊查询的列
			this.filter = '';
			this.iptPage = 1;
			
			//这个作废，不太适合这么处理
			this.pendcol = null;//挂起列（该列发生值改变时可以进行拦截），使用列名标识，取消挂起时设为null


			//////////////////////////////////////////////////////////////////////////
    		if(options.idColumnDefine!=undefined){
    			this.userdata.idColumnDefine = options.idColumnDefine;
    		}
    		if(options.idColumnName!=undefined){
    			this.userdata.idColumnName = options.idColumnName;
    		}

	   		//需要验证数据有效性的列
    		if(options.validColumns!=undefined){
    			this.userdata.validColumns = options.validColumns;
    		}
    		
    		
    		if(options.reader!=undefined){
    			this.reader = this.httpUrl + options.reader;
    		}
    		if(options.writer!=undefined){
    			this.writer = this.httpUrl + options.writer;
    		}
    		if(options.deleter!=undefined){
    			this.deleter = this.httpUrl + options.deleter;
    		}
    		if(options.creater!=undefined){
    			this.creater = this.httpUrl + options.creater;
    		}else{
    			console.log('--------------------------creater为空');
    		}
    		if(options.valider!=undefined){
    			this.valider = this.httpUrl + options.valider;
    		}

    		
    		if(options.defCols!=undefined){
    			this.defCols = options.defCols;
    		}
    		if(options.autoload!=undefined){
    			this.autoload = options.autoload;
    		}
    		if(options.directDeleteMode!=undefined){
    			this.directDeleteMode = options.directDeleteMode;
    		}
    		if(options.deleteConfirm!=undefined){
    			this.deleteConfirm = options.deleteConfirm;
    		}
    		if(options.limit!=undefined){
    			this.limit = options.limit;
    		}else{
    			this.limit = -1;
    		}
    		if(options.orderBy!=undefined){
    			this.orderBy = options.orderBy;
    		}else{
    			this.orderBy = null;
    		}
    		if(options.master!=undefined){
    			this.master = options.master;
    		}
    		
    		if(options.aggregateColumns!=undefined){
    			this.aggregateColumns = options.aggregateColumns;
    		}
    		if(options.aggregate!=undefined){
    			this.aggregate = options.aggregate;
    		}
  		
    		///////////////树形////////////////////////////////////
   			//此参数必须输入
   			this.isTree = options.isTree;

   			if(options.parentRelation!=undefined){
    			this.treeOption.parentRelation = options.parentRelation;
    		}
    		if(options.nodeKindRelation!=undefined){
    			this.treeOption.nodeKindRelation = options.nodeKindRelation;
    		}
    		if(options.nodeLevelRelation!=undefined){
    			this.treeOption.nodeLevelRelation = options.nodeLevelRelation;
    		}
    		if(options.nodeSortRelation!=undefined){
    			this.treeOption.nodeSortRelation = options.nodeSortRelation;
    		}
    		if(options.rootFilter!=undefined){
    			this.treeOption.rootFilter = options.rootFilter;
    		}
    		if(options.pathRelation!=undefined){
    			this.treeOption.pathRelation = options.pathRelation;
    		}
     		//////////////////////////////////////////////////////////
     		
//    		if(options.slaveDatas){
//    			this.slaveDatas = options.slaveDatas;
//    		}
   		
    		
    		if(options.onIndexChanging!=undefined){
    			this.onIndexChanging = options.onIndexChanging;
    		}
    		if(options.onIndexChanged!=undefined){
    			this.onIndexChanged = options.onIndexChanged;
    		}

    		if(options.onBeforeRefresh!=undefined){
    			this.onBeforeRefresh = options.onBeforeRefresh;
    		}
    		if(options.onAfterRefresh!=undefined){
    			this.onAfterRefresh = options.onAfterRefresh;
    		}

    		if(options.onNewCreateParam!=undefined){
    			this.onNewCreateParam = options.onNewCreateParam;
    		}
    		if(options.onBeforeNew!=undefined){
    			this.onBeforeNew = options.onBeforeNew;
    		}
    		if(options.onAfterNew!=undefined){
    			this.onAfterNew = options.onAfterNew;
    		}

    		if(options.onNewDataAfter!=undefined){
    			this.onNewDataAfter = options.onNewDataAfter;
    		}
   		 
    		if(options.onBeforeDelete!=undefined){
    			this.onBeforeDelete = options.onBeforeDelete;
    		}
    		if(options.onAfterDelete!=undefined){
    			this.onAfterDelete = options.onAfterDelete;
    		}

    		if(options.onBeforeSave!=undefined){
    			this.onBeforeSave = options.onBeforeSave;
    		}
    		if(options.onAfterSave!=undefined){
    			this.onAfterSave = options.onAfterSave;
    		}
     		 
    		if(options.onValueChanging!=undefined){
    			this.onValueChanging = options.onValueChanging;
    		}
   		 
    		if(options.onValueChanged!=undefined){
    			this.onValueChanged = options.onValueChanged;
    		}
    		if(options.onDataChanged!=undefined){
    			this.onDataChanged = options.onDataChanged;
    		}
    		
    		///////////////////处理主从数据对象关系////////////////////////////////////////
//    		console.log('this.master-->',this.master);
    		if(this.master.data!='' && this.master.relation!=''){
    			//登记主数据
    			this.masterData = this.container[this.master.data];
//    			console.log('this.masterData-->',this.masterData);
    			//将自己作为从数据登记到主数据中
    			this.masterData.slaveDatas.push(this.name);
    		}
    		
    		
    		///////////////////////////////////////////////////////////////////////
			
			//////////////////////////监视开始////////////////////////////////////////////////////////
			/*
			//监视行索引变动
			this.watchCurrentIndex = function(newValue,oldValue,scope){
				if(newValue==oldValue){
					return;
				}
				
				if(newValue==-1 || newValue>_self.rows.length - 1){
					_self.currentID = null;
				}else{			
					var rowID = _self.rows[newValue][this.userdata.idColumnDefine].value;
					_self.currentID = rowID;
				}
				if(_self.onIndexChanged){
					var event = {};
					event.source = _self;
					event.rowIndex = newValue;
					event.originalRowIndex = oldValue;
					event.rowID = rowID;
					_self.onIndexChanged(event);
				}
			
			}
			*/
			
    		/*
			//监视当前行ID变动
			this.watchCurrentID = function(newValue,oldValue,scope){
				//如果没有变化，则不执行循环
				if(newValue==oldValue){
					return;
				}
				//如果没有变化，则不执行循环
//				if(newValue==null){
//					return;
//				}
				//判断是否有从表
				var slaveDatas = _self.slaveDatas;
				if(slaveDatas.length>0){
					//存在从表,需要调用从表的刷新函数	//遍历从data
			        for(var i=0;i<slaveDatas.length;i++){
			        	if(newValue==null){
			        		this.container.objects[slaveDatas[i]].clearData();
			        	}else{
				        	this.container.objects[slaveDatas[i]].fMasterID = newValue;
				        	if(this.container.objects[slaveDatas[i]].autoload){
					        	this.container.objects[slaveDatas[i]].refreshData();
				        	}
			        	}
			        }
				}
			}
			*/

    		/*
    		 * 2018-01-26
    		 * 本监视函数有2个功能
    		 * 1、监视前台数据与后台数据库中的数据是否保持一致，
    		 * 通过newValue中的value（前端指）与originalValue（数据库中的指）比较实现；
    		 * 2、监视前端数据改变带来的相应的事件的触发、如值改变事件等；
    		 * 说明：前端值改变事件的触发未必与前端数据与后端数据库数据不一致同时发生，
    		 * 例如：数据库中指为1，前端第一次修改为0，出发一次事件，第二次改为1，又触发一次事件，
    		 * 而最终结果是：前端数据与数据库中数据是一致的，并未改变
    		 * 
    		 * */
			this.watchRows = function(newValue,oldValue,scope){
				//var _self = this;
//				console.log('newValue-->',newValue);
//				console.log('oldValue-->',oldValue);
//				console.log('watchRows-->', 'I am watching:'+_self.concept);

				//初始化的时候不进行监视
				if(!oldValue || oldValue.length==0){
					//这种条件不存在
					return
				}
				//如果没有变化，则不执行循环
				/*
				if(newValue==oldValue){
					console.log('newValue==oldValue-->return');
					return;
				}
				*/
				
				//原值与新值共同的行数，为了处理插入和删除行带来的问题
				//console.log('newValue.length-->',newValue.length);
				//console.log('oldValue.length-->',oldValue.length);
				//插入或者删除时不适用监视器，谁说的？
				if(newValue.length>oldValue.length){
					//插入
					//console.log(_self.concept + '新增行');
					
					
					//插入行无需判断是否有value级别的值改变，只需要修改data级别的改变状态

					//下面的标识代表data是否处于可以编辑的状态，应该由UI操作
					//_self.userdata.recordState;
					//下面的标示代表是否data有变动，如新增行、删除行、或者值变动等
					_self.userdata.changed = 1;
					/*
					{
						"source" : 组件的js对象,
						"changedSource" ：触发变化的组件的js对象，当从data触发时返回从data对象,
						"selfChanged" : 是否自身变化，false：从data触发的变化,
						"type" : 触发变化的类型，包括：new、delete、refresh、valueChanged、clear，其他参数根据触发类型不同给出不同参数，参考onAfterNew等事件参数
					}
					*/
					
					//触发onDataChanged事件
					if(_self.onDataChanged){
						var event = {};
						event.source = _self;
						event.changedSource = _self;
						event.selfChanged = true;
						event.type = 'new';
						_self.onDataChanged(event);
					}

					
					
					var changedTable = 0;//判断表（包含所有行是否已经改变）改变
					//循环新对象中的每一行
					for(var i=0;i<newValue.length;i++){
						//获取当前行的id
						var id = newValue[i].userdata.recordID;
						var index = -1;
						//console.log('newValue.id-->',id);
						//寻找旧对象中对应的行
						for(var j=0;j<oldValue.length;j++){
							var ordId = oldValue[j].userdata.recordID
							//console.log('oldValue.id-->',ordId);
							if(ordId==id){
								//找到对应的行,终止循环
								index = j;
								break;
							}
						}
						//console.log('index-->',index);
						if(index==-1){
							//旧对象中不存在此行，是新增行，无法比较，只触发事件
							//console.log('新增行ID：',id);
							var changedRow = 0;//判断行（包含所有列是否存在改变）改变
							for(var obj in newValue[i]){
								if(obj.indexOf('$$')== -1 && obj!='userdata' && obj!='version'
									){
									
									//触发onValueChanging事件
									if(_self.onValueChanging){
										var event = {};
										event.source = _self;
										event.column = obj;
										event.rowIndex = i;
										event.value = newValue[i][obj].value;
										event.originalValue = null;//oldValue[index][obj].value;
										_self.onValueChanging(event);
										newValue[i][obj].value = event.value;
									}
									
									//获取列的类型
									var colType = newValue[i][obj].type;//_self.getColumnType(obj);
									//console.log('colType-->',colType);
									//转化为浮点数
									if(colType=='Decimal' || colType=='Integer'){
										//值不能为空
										if(newValue[i][obj].value==''){
											newValue[i][obj].value = 0;
										}
										//不能为非数字
										if(isNaN(newValue[i][obj].value)){
											//不是数字
											newValue[i][obj].value = 0;//oldValue[index][obj].value;
										}
									}
									
									//改变当前列的changed
									if(newValue[i][obj].value!=newValue[i][obj].originalValue){
										//列值已改变
										if(newValue[i][obj].changed==0){
											newValue[i][obj].changed = 1;
										}
									}else{
										//列值未改变
										if(newValue[i][obj].changed==1){
											newValue[i][obj].changed = 0;
										}
									}
									
									//触发onValueChanged事件
									if(_self.onValueChanged){
										var event = {};
										event.source = _self;
										event.column = obj;
										event.rowIndex = i;
										event.value = newValue[i][obj].value;
										event.originalValue = null;//oldValue[i][obj].value;
//										event.changeFlag = newValue[i][obj].changeFlag;//值改变是否由setValue函数引发，Y：是的，N：否
										_self.onValueChanged(event);
									}
									//增加下面这一个赋值动作将增加一次数组变动监视事件的发生
//									newValue[i][obj].changeFlag = '';
									
									//触发onDataChanged事件
									if(_self.onDataChanged){
										var event = {};
										event.source = _self;
										event.changedSource = _self;
										event.selfChanged = true;
										event.type = 'valueChanged';
										_self.onDataChanged(event);
									}
									
									//循环累加整行change，判断行是否改变
									//console.log('行userdata-->',newValue[i].userdata);
									changedRow = changedRow + newValue[i][obj].changed;
									//赋值行改变状态值
									newValue[i].userdata.changed = changedRow;
//									console.log('行changed-->',newValue[i].userdata.changed);
									/////////////////////////////////////////////////////////
									//判断数据有效性
//									if(_self.userdata.validColumns){
//										var columns = _self.userdata.validColumns.split(",");
//										for(var j=0;j<columns.length;j++){
//											console.log('obj-->',obj);
//											console.log('validColumn-->>',columns[j]);
//										}
//									}
									/////////////////////////////////////////////////////////
								}
							}//列循环结束
							
							//判断所有行的改变状态，以确定表的改变状态

							var recordState = newValue[i].userdata.recordState;
							//console.log('recordState-->',recordState);
							//console.log('i-->',i);
							//console.log('changed-->',changed);
							
							//循环累加所有行changed，判断表是否改变
							//console.log('行userdata-->',newValue[i].userdata);
							changedTable = changedTable + newValue[i].userdata.changed;
							
						}else{
							//此行不是新增行，进行值是否改变的比较
							//循环行中的列，判断变化点是哪一个
							var changedRow = 0;//判断行（包含所有列是否存在改变）改变
							for(var obj in newValue[i]){
								if(obj.indexOf('$$')== -1 && obj!='userdata' && obj!='version'
									){
										
										if(newValue[i][obj].value!=oldValue[index][obj].value){
											//触发onValueChanging事件
											if(_self.onValueChanging){
												var event = {};
												event.source = _self;
												event.column = obj;
												event.rowIndex = i;
												event.value = newValue[i][obj].value;
												event.originalValue = oldValue[index][obj].value;
												_self.onValueChanging(event);
												newValue[i][obj].value = event.value;
											}
										}
										
										//获取列的类型
										var colType = newValue[i][obj].type;//_self.getColumnType(obj);
										//console.log('colType-->',colType);
										//转化为浮点数
										if(colType=='Decimal' || colType=='Integer'){
											//值不能为空
											if(newValue[i][obj].value==''){
												newValue[i][obj].value = 0;
											}
											//不能为非数字
											if(isNaN(newValue[i][obj].value)){
												//不是数字
												newValue[i][obj].value = oldValue[index][obj].value;
											}
										}
										
										//改变当前列的changed
										if(newValue[i][obj].value!=newValue[i][obj].originalValue){
											//列值已改变
											if(newValue[i][obj].changed==0){
												newValue[i][obj].changed = 1;
											}
										}else{
											//列值未改变
											if(newValue[i][obj].changed==1){
												newValue[i][obj].changed = 0;
											}
										}
										
										//经过changing后重新取值
										if(newValue[i][obj].value!=oldValue[index][obj].value){

											//值正在改变事件，暂时没有添加
											//触发onValueChanged事件
											if(_self.onValueChanged){
												var event = {};
												event.source = _self;
												event.column = obj;
												event.rowIndex = i;
												event.value = newValue[i][obj].value;
												event.originalValue = oldValue[index][obj].value;
//												event.changeFlag = newValue[i][obj].changeFlag;//值改变是否由setValue函数引发，Y：是的，N：否
												_self.onValueChanged(event);
											}
											//增加下面这一个赋值动作将增加一次数组变动监视事件的发生
//											newValue[i][obj].changeFlag = '';
											
											//触发onDataChanged事件
											if(_self.onDataChanged){
												var event = {};
												event.source = _self;
												event.changedSource = _self;
												event.selfChanged = true;
												event.type = 'valueChanged';
												_self.onDataChanged(event);
											}
											console.log('数据已经改变的列：-->',obj);

											/////////////////////////////////////////////////////////
											//判断数据有效性
											if(_self.userdata.validColumns){
												var columns = _self.userdata.validColumns.split(",");
												for(var j=0;j<columns.length;j++){
													//console.log('obj-->',obj);
													//console.log('validColumn-->>',columns[j]);
													if(obj==columns[j]){
														console.log('找到需要校验的列-->',obj);
													}
												}
											}
											/////////////////////////////////////////////////////////
											
										}
										
										//循环累加整行change，判断行是否改变
										//console.log('行userdata-->',newValue[i].userdata);
										changedRow = changedRow + newValue[i][obj].changed;
										//赋值行改变状态值
										newValue[i].userdata.changed = changedRow;
//										console.log('行changed-->',newValue[i].userdata.changed);
									}
							}//列循环结束
							
							//判断所有行的改变状态，以确定表的改变状态

							var recordState = newValue[i].userdata.recordState;
							//console.log('recordState-->',recordState);
							//console.log('i-->',i);
							//console.log('changed-->',changed);
							if(changedRow!=0){
								//如果不是新增，则在值改变的情况下，修改为编辑
								if(recordState=='none'){
//									console.log('recordState==none-->','改变行状态为edit');
									newValue[i].userdata.recordState='edit';
								}
							}else{
								//如果修改状态编辑
								if(recordState=='edit'){
//									console.log('recordState==none-->','改变行状态为edit');
									newValue[i].userdata.recordState='none';
								}
							}
							
							//循环累加所有行changed，判断表是否改变
							//console.log('行userdata-->',newValue[i].userdata);
							changedTable = changedTable + newValue[i].userdata.changed;
							
						}
					}//行循环结束
					//赋值表改变状态值
					//console.log('表改变状态值-->',changedTable);
					_self.userdata.changed = changedTable;
					
					//判断是否存在主数据，改变主表的行状态为edit
					if(changedTable>0 && _self.masterData!=null){
						//存在主数据
						recordState = _self.masterData.rows[_self.masterData.getCurrentIndex()].userdata.recordState;
						if(recordState=='none'){
							_self.masterData.rows[_self.masterData.getCurrentIndex()].userdata.recordState = 'edit';
						}
					}
					
					
				}
				
				else if(newValue.length<oldValue.length){
					//删除	
					//console.log(_self.concept + '减少行');
					//可以出发删除之后事件
					//数据重新加载时也可能触发？？？？？？？？？？？，如主表新增一行，从表就会触发
					
					//插入行无需判断是否有value级别的值改变，只需要修改data级别的改变状态

					//下面的标识代表data是否处于可以编辑的状态，应该由UI操作
					//_self.userdata.recordState;
					//下面的标示代表是否data有变动，如新增行、删除行、或者值变动等
					_self.userdata.changed = 1;
					/*
					{
						"source" : 组件的js对象,
						"changedSource" ：触发变化的组件的js对象，当从data触发时返回从data对象,
						"selfChanged" : 是否自身变化，false：从data触发的变化,
						"type" : 触发变化的类型，包括：new、delete、refresh、valueChanged、clear，其他参数根据触发类型不同给出不同参数，参考onAfterNew等事件参数
					}
					*/
					
					//触发onDataChanged事件
					if(_self.onDataChanged){
						var event = {};
						event.source = _self;
						event.changedSource = _self;
						event.selfChanged = true;
						event.type = 'delete';
						_self.onDataChanged(event);
					}

					
					
					var changedTable = 0;//判断表（包含所有行是否已经改变）改变
					//循环对象中的每一行
					for(var i=0;i<oldValue.length;i++){
						//获取当前行的id
						var id = oldValue[i].userdata.recordID;
						var index = -1;
						//console.log('oldValue.id-->',id);
						//寻找新值对应的行
						for(var j=0;j<newValue.length;j++){
							var ordId = newValue[j].userdata.recordID
							//console.log('newValue.id-->',ordId);
							if(ordId==id){
								//找到对应的行,终止循环
								index = j;
								//continue;
								break;
							}
						}
						//console.log('index-->',index);
						if(index==-1){
							//不存在，被删除的行，无法比较
							//console.log('减少行ID：',id);
							
						}else{
							//存在，进行比较
							//循环行中的列，判断变化点是哪一个
							var changedRow = 0;//判断行（包含所有列是否存在改变）改变
							for(var obj in newValue[index]){
								if(obj.indexOf('$$')== -1 && obj!='userdata' && obj!='version'
									){
										//console.log('obj-->>',obj);
										if(newValue[index][obj].value!=oldValue[i][obj].value){
											//触发onValueChanging事件
											if(_self.onValueChanging){
												var event = {};
												event.source = _self;
												event.column = obj;
												event.rowIndex = i;
												event.value = newValue[index][obj].value;
												event.originalValue = oldValue[i][obj].value;
												_self.onValueChanging(event);
												newValue[index][obj].value = event.value;
											}
										}
										//获取列的类型
										var colType = newValue[index][obj].type;//_self.getColumnType(obj);
										//console.log('colType-->',colType);
										//转化为浮点数
										if(colType=='Decimal' || colType=='Integer'){
											//值不能为空
											if(newValue[index][obj].value==''){
												newValue[index][obj].value = 0;
											}
											//不能为非数字
											if(isNaN(newValue[index][obj].value)){
												//不是数字
												newValue[index][obj].value = oldValue[i][obj].value;
											}
										}
										
										//改变当前列的changed
										if(newValue[index][obj].value!=newValue[index][obj].originalValue){
											//列值已改变
											if(newValue[index][obj].changed==0){
												newValue[index][obj].changed = 1;
											}
										}else{
											//列值未改变
											if(newValue[index][obj].changed==1){
												newValue[index][obj].changed = 0;
											}
										}
										
										//经过changing后重新取值
										if(newValue[index][obj].value!=oldValue[i][obj].value){

											//值正在改变事件，暂时没有添加
											//触发onValueChanged事件
											if(_self.onValueChanged){
												var event = {};
												event.source = _self;
												event.column = obj;
												event.rowIndex = i;
												event.value = newValue[index][obj].value;
												event.originalValue = oldValue[i][obj].value;
//												event.changeFlag = newValue[index][obj].changeFlag;//值改变是否由setValue函数引发，Y：是的，N：否
												_self.onValueChanged(event);
											}
											//增加下面这一个赋值动作将增加一次数组变动监视事件的发生
//											newValue[index][obj].changeFlag = '';
											
											//触发onDataChanged事件
											if(_self.onDataChanged){
												var event = {};
												event.source = _self;
												event.changedSource = _self;
												event.selfChanged = true;
												event.type = 'valueChanged';
												_self.onDataChanged(event);
											}
											
										}
										
										//循环累加整行change，判断行是否改变
										//console.log('行userdata-->',newValue[index].userdata);
										changedRow = changedRow + newValue[index][obj].changed;
										//赋值行改变状态值
										newValue[index].userdata.changed = changedRow;
//										console.log('行changed-->',newValue[index].userdata.changed);
									}
							}//列循环结束
							
							//判断所有行的改变状态，以确定表的改变状态

							var recordState = newValue[index].userdata.recordState;
							//console.log('recordState-->',recordState);
							//console.log('i-->',i);
							//console.log('changed-->',changed);
							if(changedRow!=0){
								//如果不是新增，则在值改变的情况下，修改为编辑
								if(recordState=='none'){
//									console.log('recordState==none-->','改变行状态为edit');
									newValue[index].userdata.recordState='edit';
								}
							}else{
								//如果修改状态编辑
								if(recordState=='edit'){
//									console.log('recordState==none-->','改变行状态为edit');
									newValue[index].userdata.recordState='none';
								}
							}
							
							//循环累加所有行changed，判断表是否改变
							//console.log('行userdata-->',newValue[index].userdata);
							changedTable = changedTable + newValue[index].userdata.changed;
							
						}

					}//行循环结束
					//赋值表改变状态值
					//console.log('表改变状态值-->',changedTable);
					_self.userdata.changed = changedTable;
					
					//判断是否存在主数据，改变主表的行状态为edit
					if(changedTable>0 && _self.masterData!=null){
						//存在主数据
						recordState = _self.masterData.rows[_self.masterData.getCurrentIndex()].userdata.recordState;
						if(recordState=='none'){
							_self.masterData.rows[_self.masterData.getCurrentIndex()].userdata.recordState = 'edit';
						}
					}
					
				}
				
				else{
					
					//修改（非插入和删除）	
					//console.log(_self.concept + '没新增也没减少');

					var changedTable = 0;//判断表（包含所有行是否已经改变）改变
					
					//获取当前行（无论是旧值还是新值，当前行的索引是同一个），只监视当前行，这样就无需循环每一行啦
					//只监视单行有问题（从表循环赋值时无法监视）
					//var i = _self.currentIndex;
					
					//循环对象中的每一行
					for(var i=0;i<newValue.length;i++){
						//循环行中的列，判断变化点是哪一个
						var changedRow = 0;//判断行（包含所有列是否存在改变）改变
						for(var obj in newValue[i]){
							if(obj.indexOf('$$')== -1 && obj!='userdata' && obj!='version'
								){
									//console.log(_self.concept+'.obj-->>',obj);
									//这个比较可以监视值改变事件的发生
									if(newValue[i][obj].value!=oldValue[i][obj].value){
										
										//触发onValueChanging事件
										if(_self.onValueChanging){
											var event = {};
											event.source = _self;
											event.column = obj;
											event.rowIndex = i;
											event.value = newValue[i][obj].value;
											event.originalValue = oldValue[i][obj].value;
											event.cancel = false;
											_self.onValueChanging(event);
											
											//保留前端赋值
											newValue[i][obj].value = event.value;
										}
									}
									
									//在值改变之前判断新值合法性
									//console.log('newValue['+i+']-->',newValue[i]);
									//获取列的类型
									var colType = newValue[i][obj].type;//_self.getColumnType(obj);
									//console.log('colType-->',colType);
									//转化为浮点数
									if(colType=='Decimal' || colType=='Integer'){
										//值不能为空
										if(newValue[i][obj].value==''){
											newValue[i][obj].value = 0;
										}
										//不能为非数字
										if(isNaN(newValue[i][obj].value)){
											//不是数字
											newValue[i][obj].value = oldValue[i][obj].value;
										}
									}
									
									//监视前端数据是否与后端数据库数据一致，改变当前列的changed
									if(newValue[i][obj].value!=newValue[i][obj].originalValue){
										//列值已改变
										//console.log(_self.name+'第'+i+'行'+obj+'列值改变（与数据库不同）！');
										if(newValue[i][obj].changed==0){
											newValue[i][obj].changed = 1;
										}
									}else{
										//列值未改变
										if(newValue[i][obj].changed==1){
											newValue[i][obj].changed = 0;
										}
									}

									//经过changing后重新取值
									//这个比较可以监视值改变事件的发生
									if(newValue[i][obj].value!=oldValue[i][obj].value){
										//值正在改变事件，暂时没有添加
										//将新值赋予原值，避免每一次循环都判断为发生改变
										//newValue[i][obj].originalValue = value;
										
										//触发onValueChanged事件
										if(_self.onValueChanged){
											var event = {};
											event.source = _self;
											event.column = obj;
											event.rowIndex = i;
											event.value = newValue[i][obj].value;
											event.originalValue = oldValue[i][obj].value;
//											event.changeFlag = newValue[i][obj].changeFlag;//值改变是否由setValue函数引发，Y：是的，N：否
											_self.onValueChanged(event);
										}
										//增加下面这一个赋值动作将增加一次数组变动监视事件的发生
//										newValue[i][obj].changeFlag = '';
										
										//触发onDataChanged事件
										if(_self.onDataChanged){
											var event = {};
											event.source = _self;
											event.changedSource = _self;
											event.selfChanged = true;
											event.type = 'valueChanged';
											_self.onDataChanged(event);
										}
										//console.log('concept',_self.concept);
										//console.log('数据已经改变的列：-->',obj);

										/////////////////////////////////////////////////////////
										//判断数据有效性
//										if(_self.userdata.validColumns){
//											var columns = _self.userdata.validColumns.split(",");
//											for(var j=0;j<columns.length;j++){
//												console.log('obj-->',obj);
//												console.log('validColumn-->>',columns[j]);
//												if(obj==columns[j]){
//													console.log('找到需要校验的列-->',obj);
//													var param = {};
//													_self.validData(param);
//												}
//											}
//										}
										/////////////////////////////////////////////////////////
									}
									
									//循环累加整行change，判断行是否改变
									//console.log('行userdata-->',newValue[i].userdata);
									changedRow = changedRow + newValue[i][obj].changed;
									//赋值行改变状态值
									newValue[i].userdata.changed = changedRow;
//									console.log('行changed-->',newValue[i].userdata.changed);
								}
						}//列循环结束
						
						//判断所有行的改变状态，以确定表的改变状态
						var recordState = newValue[i].userdata.recordState;
						//console.log('recordState-->',recordState);
						//console.log('i-->',i);
						//console.log('changed-->',changed);
						if(changedRow!=0){
							//如果不是新增，则在值改变的情况下，修改为编辑
							//console.log(_self.name+'第'+i+'行有值改变（与数据库不同）！');
							if(recordState=='none'){
//								console.log('recordState==none-->','改变行状态为edit');
								newValue[i].userdata.recordState='edit';
							}
						}else{
							//如果修改状态编辑
							if(recordState=='edit'){
//								console.log('recordState==none-->','改变行状态为edit');
								newValue[i].userdata.recordState='none';
							}
						}
						
						//循环累加所有行changed，判断表是否改变
						//console.log('行userdata-->',newValue[i].userdata);
						changedTable = changedTable + newValue[i].userdata.changed;
						

					}//行循环结束
					
					//赋值表改变状态值
					//console.log('表改变状态值-->',changedTable);
					_self.userdata.changed = changedTable;
					//判断是否存在主数据，改变主表的行状态为edit
					
					if(changedTable>0 && _self.masterData!=null){
						//存在主数据
						recordState = _self.masterData.rows[_self.masterData.getCurrentIndex()].userdata.recordState;
						if(recordState=='none'){
							_self.masterData.rows[_self.masterData.getCurrentIndex()].userdata.recordState = 'edit';
						}
					}
				}
				
			
			}//监视结束

			/*
			//监视行增减
			this.watchCollection = function(newValue,oldValue,scope){
			
			
			}//true代表深度监视，包括对象的属性，而不是简单的一个值
			*/
			//////////////////////////监视结束////////////////////////////////////////////////////////

    		/////////////////////////////////////////////////////////////////////////
    		/*
    		//接收监视器回调函数
    		if(options.rowsWatcherFn){
    			this.rowsWatcherFn = options.rowsWatcherFn;
    		}
    		this.startRowsWatcher = function(){
    			this.deregRows = this.rowsWatcherFn()
    		}
    		this.shutdownRowsWatcher = function(){
    			this.deregRows();
    		}
    		*/
    		////////////////////////////////////////////////////////////////////////////////////////
    		
//			if(this.autoload && this.masterData==null){
//				//自动装载
//				this.refreshData();
//			}
//			this.startRowsWatcher();

			this.sayHi = function() {  
			    console.log("Hi ! I am "+this.name);  
			}
			

    	};
    	
    	
    	
    	
    	BizData.prototype = {
				
				
				
				readonly:function(){
					if(this.userdata.recordState=='none'){
						return true;
					}else{
						return false;
					}
				}
				,getIDs:function(){
					var arrayIDs = new Array();
					for(var i=0;i<this.rows.length;i++){
						arrayIDs.push(this.rows[i][this.userdata.idColumnDefine].value);
					}
					return arrayIDs;
				}
				,getSum:function(column){
					var sum = 0;
					for(var i=0;i<this.rows.length;i++){
						sum = this.accAdd(sum , parseFloat(this.rows[i][column].value));
					}
					return sum;
				}
				,getCurrentState : function(){
					if(this.rows.length<=0 || this.getCurrentIndex()== null || this.getCurrentIndex()>this.rows.length - 1)return null;
					if(this.rows[this.getCurrentIndex()].state.value=='confirm'){
						return true;
					}else{
						return false;
					}
				}
				
				,getCurrentStatus : function(){
					if(this.rows.length<=0 || this.getCurrentIndex()== null || this.getCurrentIndex()>this.rows.length - 1)return null;
					if(this.rows[this.getCurrentIndex()].status.value=='close'){
						return true;
					}else{
						return false;
					}
				}
				
				,getCurrentAudit : function(){
					if(this.rows.length<=0 || this.getCurrentIndex()== null || this.getCurrentIndex()>this.rows.length - 1)return null;
					if(this.rows[this.getCurrentIndex()].audit.value=='confirm'){
						return true;
					}else{
						return false;
					}
				}
				
				,getFlowType : function(){
					if(this.rows.length<=0 || this.getCurrentIndex()== null || this.getCurrentIndex()>this.rows.length - 1)return -1;
					if(this.rows[this.getCurrentIndex()].flowType!=undefined){
						if(this.rows[this.getCurrentIndex()].flowType.value!=undefined){
							return this.rows[this.getCurrentIndex()].flowType.value;
						}else{
							return -1
						}
					}else{
						return -1
					}
				}
				
				,getValue : function(col, rowID){
					var rows = this.rows;
					var index = this.getIndex(rowID);
					var row = rows[index];
					for(var obj in row){
						if(obj==col){
							return row[obj].value;
						}
					}
					return '';
				}
				
				,setValue : function(col, value, rowID, changeFlag){
					var rows = this.rows;
					var index = this.getIndex(rowID);
					var row = rows[index];
					for(var obj in row){
						if(obj==col){
							row[obj].value = value;
//							console.log('obj-->',obj);
//							console.log('row[obj]-->',row[obj]);
							//增加下面这一个值将增加一次数组变动监视事件的发生
							row[obj].changeFlag = changeFlag;//'Y';
						}
					}
				}
				
				,getAggregateValue : function(col){
					var values = this.aggregateValues;
//					console.log('vaules-->',values);
					for(var obj in values){
						if(obj==col){
							return values[obj].value;
						}
					}
					return '';
				}
				
				,getFilter : function(name){
					for(var i=0;i<this.filters.length;i++){
						if(this.filters[i].name==name){
							return this.filters[i].filter;
						}
					}
					return '';
				}
				
				,setFilter : function(name, filter){
//					console.log(name);
					//判断名称是否存在
					var b = false;
					for(var i=0;i<this.filters.length;i++){
						if(this.filters[i].name==name){
							b = true;
							this.filters[i].filter = filter;
						}
					}
					if(b==false){
						var f = {"name":name,"filter":filter};
						this.filters.push(f);
					}
					return b;
				}
				
				,deleteFilter : function(name){
					for(var i=0;i<this.filters.length;i++){
						if(this.filters[i].name==name){
							this.filters.splice(i,1)
						}
					}
				}
				
				,clearFilters : function(){
					this.filters = [];
				}
				
				,getColumnType : function(col){
					/*
					for(var obj in this.defCols){
						if(obj==col){
							return this.defCols[obj].type;
						}
					}
					*/
					var columns = this.userdata.relationAlias.split(",");
					var types = this.userdata.relationTypes.split(",");
					for(var i=0;i<columns.length;i++){
						if(col==columns[i])	return types[i];
					}
					return null;
				}
				
				,getDataAccessPerm : function(){
					return this.dataAccessPerm;
				}

				//设置行状态
				,setState : function(rowID, recordState){
					var rows = this.rows;
					var index = this.getIndex(rowID);
					var row = rows[index];
					row.userdata.recordState = recordState;
				}
				
				,bof : function(){
					if(this.getCurrentIndex()==null || this.getCurrentIndex()<=0){
						return true;
					}else{
						return false;
					}
				}
				,eof : function(){
					if(this.getCurrentIndex()==null || this.getCurrentIndex()==this.getCount() - 1){
						return true;
					}else{
						return false;
					}
				}
				
				,getCount : function(){
					return this.rows.length;
				}

				//移动行
				,moveRowPro : function(offset, rowID){
					//-1为向前移动一行；1为向后移动一行
					var index = this.getIndex(rowID);
					if((index + offset)<0 || (index + offset)>=this.getTotal())
						return;
					var row = this.rows[index];
					//删除行
					this.rows.splice(index,1);
					//插入行
					this.rows.splice(index + offset,0,row);
					//改变当前索引
					this.setCurrentIndex(index + offset);
				}

				//第一行
				,firstRow : function () {
					this.setCurrentIndex(0);
				}
				//下一行
				,nextRow : function () {
					if (this.getCurrentIndex() < this.getCount() - 1) {
						this.setCurrentIndex(this.getCurrentIndex() + 1);
					}
				}
				
				//上一行
				,prevRow : function () {
					if (this.getCurrentIndex() > 0) {
						this.setCurrentIndex(this.getCurrentIndex() - 1);
					}
				}
				//最后一行
				,lastRow : function () {
					this.setCurrentIndex(this.getCount() - 1);
				}
				
				,getTotal : function(){
					return this.total;
				}
				,clearData : function(){
//					this.totalPage = 1; //总页数
//					this.currentPage = 1;
//					this.pages = []; //翻页按钮集合
//					this.total = 0; //总行数
//					this.offset = 0; //行偏移(前端计算，带入后端)
					this.setCurrentIndex(null);
					this.deleterows = new Array();
					this.rows = new Array();
				}
				,getCurrentIndex : function(){
					return this.currentIndex;
				}
				,getIndex : function(rowID){
					for(var i=0;i<this.rows.length;i++){
						if(this.rows[i][this.userdata.idColumnDefine].value==rowID)
							return i;
					}
					return null;
				}
				,getCurrentID : function(){
					return this.currentID;
				}
				,getID : function(index){
					var row = this.rows[index];
					return row[this.userdata.idColumnDefine].value;
				}
				
				//设置当前rowID
				,setCurrentID : function(rowID) {
					this.currentID = rowID;
					/*
					//判断是否有从表
					var slaveDatas = this.slaveDatas;
					if(slaveDatas.length>0){
						//存在从表,需要调用从表的刷新函数	//遍历从data
				        for(var i=0;i<slaveDatas.length;i++){
				        	if(rowID==null){
				        		if(this.container.objects[slaveDatas[i]]){
					        		this.container.objects[slaveDatas[i]].clearData();
				        		}
				        	}else{
				        		if(this.container.objects[slaveDatas[i]]){
						        	this.container.objects[slaveDatas[i]].fMasterID = rowID;
						        	if(this.container.objects[slaveDatas[i]].autoload){
							        	this.container.objects[slaveDatas[i]].refreshData();
						        	}
				        		}
				        	}
				        }
					}
					*/
				}
				
				//设置当前索引
				,setCurrentIndex : function(index) {
					/*
					var rowID = null;
					if(index!=null){
						rowID = this.rows[index][this.userdata.idColumnDefine].value;
					}
					var originalRowID = this.getCurrentID();
					var originalRowIndex = this.getCurrentIndex();
					*/
					
					//原索引
					var originalRowIndex = this.getCurrentIndex();

					//原ID
					var originalRowID = this.getCurrentID();

					//新ID
					var rowID = null;
					if(index!=null){
						if(this.rows.length>0){
							if(index>=this.rows.length){
								index = 0;
							}
							//console.log('setCurrentIndex.index-->>',index);
							rowID = this.rows[index][this.userdata.idColumnDefine].value;
						}
						//挂载子节点数据，如果是树形
						///////////////////////////////////////////////////////////////
						if(this.isTree==true){
							//挂载子节点数据
							var row = this.rows[index];
							if(this.treeOption.rootFilter!='' && row.$$isMounted!=true && row.nodeKind.value!='nkLeaf'){
								this.mountChildData(rowID,index);
								//标记当前行已挂载
								row.$$isMounted=true;
							}
						}
						////////////////////////////////////////////////////////////////
					}
					
					//如果索引和ID都相等，则直接返回
					if(index==originalRowIndex & rowID==originalRowID){
						return;
					}
					
					/**
					name:bizData#onIndexChanging
					description: <b>[回调型事件]</b>行记录变化中
					@param {object} event 
					<br/><b>结构如下：</b>
					<xmp> 
					{
						"source" : 组件的js对象,
						"rowID" : 行Id,
						"rowIndex" : 行索引,
						"originalRowID" : 原行Id,
						"originalRowIndex" : 原行索引
					}
					</xmp>	
				    */
					//触发onIndexChanging事件
					if(this.onIndexChanging){
						var event = {};
						event.source = this;
						event.rowID = rowID;
						event.rowIndex = index;
						event.originalRowID = originalRowID;
						event.originalRowIndex = originalRowIndex;
						this.onIndexChanging(event);
					}
					
//					console.log('rowID-->',rowID);
//					console.log('rowIndex-->',index);
//					console.log('originalRowID-->',originalRowID);
//					console.log('originalRowIndex-->',originalRowIndex);
					//改变索引
					this.currentIndex = index;
					this.setCurrentID(rowID);

					/**
						name:bizData#onIndexChanged
						description: <b>[回调型事件]</b>行记录变化
						@param {object} event 
						<br/><b>结构如下：</b>
						<xmp> 
						{
							"source" : 组件的js对象,
							"rowID" : 行Id,
							"rowIndex" : 行索引
						}
						</xmp>	
					*/
					//触发onIndexChanged事件
					if(this.onIndexChanged){
						var event = {};
						event.source = this;
						event.rowID = rowID;
						event.rowIndex = index;
						this.onIndexChanged(event);
					}
						
				}
				
				//回车搜索
				,searchEnter : function(e) {
					//如果是回车键
					if(e.keyCode == 13){
						this.refreshData();
					}
				}
				
				
				//由下拉列表改变每页行数,limit调用
				,limitChanged : function(){
					this.refreshData();
					
				}
				
				//翻页
				//首页
				,firstPage : function () {
					this.loadPageData(1);
				}
				
				//下一页
				,nextPage : function (append) {
					//如果append参数不存在，代表单独加载此页数据，需要清除原来的数据。
					//否则，代表追加，不清除原来的数据
					/*
					if(!append){
						this.clearData();
					}
					*/
					
					if (this.currentPage < this.totalPage) {
					    var pageIndex = this.currentPage + 1;
//					    this.offset = this.offset + this.limit ;
					    this.loadPageData(pageIndex,append);
					}
				}
				
				//上一页
				,prevPage : function () {
					if (this.currentPage > 1) {
						var pageIndex = this.currentPage - 1;
//					    this.offset = this.offset - this.limit ;
					    this.loadPageData(pageIndex);
					}
				}
				
				//末页
				,lastPage : function () {
					this.loadPageData(this.totalPage);
				}
				
				
				//翻到多少页
				,turnto : function () {
					if(angular.isNumber(this.iptPage)){
						if(this.iptPage<1){
							this.iptPage=1;
						}
						if(this.iptPage>this.totalPage){
							this.iptPage=this.totalPage;
						}
						this.loadPageData(this.iptPage);
					}
				}
				
				//初始化分页
				,initPage : function() {
					//分页
					//获取总页数
					//获取总页数，当offset==0时
					if(this.offset == 0){
						this.total = this.userdata['sys.count'];
					}
					//this.offset = this.data.userdata['sys.offset'];
					if(this.limit == -1){
						this.totalPage = 1;
					}else{
					    this.totalPage = Math.ceil(this.total / this.limit);
					}
					//生成数字链接
					if (this.currentPage > 1 && this.currentPage < this.totalPage) {
					    this.pages = [
					        this.currentPage - 1,
					        this.currentPage,
					        this.currentPage + 1
					    ];
					} else if (this.currentPage == 1 && this.totalPage > 1) {
					    this.pages = [
					        this.currentPage,
					        this.currentPage + 1
					    ];
					} else if (this.currentPage == this.totalPage && this.totalPage > 1) {
					    this.pages = [
					        this.currentPage - 1,
					        this.currentPage
					    ];
					}
					//生成数字连接完成
				
				}
				
				,initRowOriginalValue : function(row){
					var _self = this;

					//增加originalValue和changed，保存原始值和改变状态
					//行循环
					//启用行循环（为了增加userdata.checked）
//					row.userdata.changed=0;
//					row.userdata.recordState='none';
					row.userdata.checked=false;
					row.userdata.recordID=row[this.userdata.idColumnDefine].value;
//					for(var column in this.defCols){
//						var type = this.defCols[column].type;
					var columns = this.userdata.relationAlias.split(",");
					var types = this.userdata.relationTypes.split(",");
					for(var i=0;i<columns.length;i++){
						var column = columns[i];
						var type = types[i];
						//console.log(column+':'+type);
						
						//转化为浮点数
//						if(type=='Decimal'){
//							if(row[column].value==null){
//								row[column].value = 0;
//							}else{
//								row[column].value = parseFloat(row[column].value);
//							}
//						}
						if(type=='Decimal'){
							if(row[column].value==null){
								console.log('initRowOriginalValue.column-->>','错误：列'+column+'为空！');
								//alert('错误：列'+column+'为空！');
							}
							/*
							if(isNaN(row[column].value)==true){
								//非数字：true
								row[column].value = parseFloat(row[column].value);
							}
							*/
							row[column].value = parseFloat(row[column].value);
						}
						//转化为整数
//						if(type=='Integer'){
//							if(row[column].value==null){
//								row[column].value = 0;
//							}
//						}
						
						//转化为日期
						//后台会发生这个错误：Unparseable date: ""
						//后台可以接收日期值为null，但是不可以接收''
						//前台可以接收日期值为''，但是不可以接收null
						if(type=='Date' || type=='DateTime' || type=='String'){
							if(row[column].value==null){
								row[column].value = '';
							}
						}
						
						row[column].originalValue = row[column].value;
						row[column].changed = 0;
						row[column].type = type;
						
						
					}
					return row;
				}
				
				,initOriginalValue : function(rows){
					//增加originalValue和changed，保存原始值和改变状态
					//行循环
					for(var index=0;index<rows.length;index++){
						//启用行循环（为了增加userdata.checked）
						this.initRowOriginalValue(rows[index]);						
					}
					
					return rows;
				}
				
				//判断字符串str是否为JSON字符串
				/*
				,isJSON : function(str) {
				    if (typeof str == 'string') {
				        try {
				            var obj=JSON.parse(str);
				            if(typeof obj == 'object' && obj ){
				                return true;
				            }else{
				                return false;
				            }

				        } catch(e) {
				            console.log('error：'+str+'!!!'+e);
				            return false;
				        }
				    }
				    console.log('It is not a string!')
				}
				*/

				

				/*
				 * 参数：
				 * fParent：父节点ID
				 * index：子节点数据挂在位置
				 * 以上参数只是数形结构子节点数据挂载使用，
				 * 其他时候调用，无需带入参数
				 */
				//获取数据，然后调用装载数据函数
				,getData : function(fParent,index) {
					var _self = this;
//					$.LoadingOverlay("show");
					
					var options = {
					    // 分页信息 – 行数
					    "limit" : this.limit,
					    // 分页信息 – 行偏移
					    "offset" : this.offset,
					    // 检索关键字
					    "search" : this.search,
					    // 过滤条件
					    "filter" : this.filter,
					    // 排序
					    "orderBy" : this.orderBy,
					    //id
					    "id" : this.id,
					    //主表id
					    "fMasterID" : this.fMasterID
					    //////////////////////////////////////////////////
			    		,"concept" : this.concept
			    		,"userdata" : this.userdata
			    		,"aggregateColumns" : this.aggregateColumns
			    		,"aggregate" : this.aggregate
			    		,"filters" : this.filters
			    		,"url" : this.url
					};
				    // 列定义，里面包含列名和列数据类型
//					if(this.defCols){
//						options.columns = this.defCols;
//					}
					//获取子节点数据，树形专用
					if(fParent){
						//加载子节点数据
						options.fParent = fParent;
						//去掉下面两个限制条件
						options.id = null;
						options.fMasterID = null;
					}else{
//						console.log('options-->',options);
						//判断是否为tree（确定是否一次加载）
						//如果是加载子节点数据则不需要下面的处理
						if(this.isTree){
							//console.log('this.treeOption.rootFilter-->',this.treeOption.rootFilter);
							if(this.treeOption.rootFilter!=''){
								//额外处理filter
								var filter = this.filter;
								if(filter!=''){
									filter = this.treeOption.rootFilter + ' AND ' + filter;
								}else{
									filter = this.treeOption.rootFilter;
								}
								options.filter = filter;
							}
						}
					}

					/*
				    var xhr = new XMLHttpRequest();
				    // xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
				    xhr.open('POST',this.reader);
				    xhr.setRequestHeader("Content-type", "application/json");
				    console.log('xhr-->>', xhr);
				    xhr.onreadystatechange = function () {
				      console.log('xhr.readyState-->>', xhr.readyState);
				      console.log('xhr.status-->>', xhr.status);
				      // 这步为判断服务器是否正确响应
				      if (xhr.readyState == 4 && xhr.status == 200) {
				        console.log('xhr.responseText-->>',xhr.responseText);
				        console.log('xhr.response-->>',xhr.response);
				        //xhr.responseText和xhr.response返回的之时相同的
				        
				        if(_self.isJSON(xhr.responseText)){
				        	var responseJSON = JSON.parse(xhr.responseText);
					        console.log(responseJSON);
				        }
				      }
				    };
				    xhr.send(JSON.stringify(options));
				    */

					$.ajax({
			            type: "POST",
			            async : false,//同步执行
			            url: this.reader,
			            data: JSON.stringify(options),// "{}",
			            contentType: "application/json; charset=utf-8",
			            dataType: "json",
//			            processData: false,
			            success: function (data) {
			                // Play with returned data in JSON format
//			            	console.log('BizData.success.name-->',_self.name);
//			            	console.log('BizData.success.query-->',data);
//			            	console.log('BizData.fParent-->',fParent);
			            	if(data.code==0){
//			            		console.log('BizData.getData.rows.length-->>',data.data.rows.length);
			            		//挂载子节点数据（树形数据专用）
				            	if(fParent){
//					            	console.log('BizData.fParent-->挂载子节点');
									//装载
									var newRows = _self.initOriginalValue(data.data.rows);
									//数组合并
//									console.log('_self.rows-->',_self.rows);
//									console.log('newRows-->',newRows);
									//这种合并不行
									//_self.rows.concat(newRows);
									//这种合并就行，原因是合并不会影响原来的数据，而是返回合并后的数组
									//_self.rows = _self.rows.concat(newRows);
									//这种可以
									for(var i=0;i<newRows.length;i++){
//										newRows[i].$$isVisible=true;
										_self.rows.splice(index+1+i,0,newRows[i]);
									}
//									_self.rows.splice(index+1,0,newRows);
				            		
				            	}else{
				            		//加载普通数据和第一级树形数据
//					            	console.log('BizData.fParent-->非挂载子节点');
//					            	console.log('BizData.success.query-->>data.data-->',data.data);
				            		_self.loadData(data.data);
				            	}
								
								/**
								name:bizData#onAfterRefresh
								description: <b>[回调型事件]</b>业务数据刷新后
								@param {object} event 
								<br/><b>结构如下：</b>
								<xmp> 
								{
									"source" : 组件的js对象
									"limit" : 页大小, 
									"offset" : 偏移,
									"success" : 是否成功刷新
								}
								</xmp>	
								*/
								
								//添加行之后触发此事件	
								if(_self.onAfterRefresh){
									var event = {};
									event.source = _self;
									event.limit = _self.limit;
									event.offset = _self.offset;
									event.success = true;//(data!=null);
									_self.onAfterRefresh(event);
								}
			            	}else{
				            	alert("数据加载函数调用错误："+data.msg+',错误代码：'+data.code);
			            	}
			            	
			            }
						/*
						,error: function(XMLHttpRequest, textStatus, errorThrown){
			            	_self.ajaxError(XMLHttpRequest, textStatus, errorThrown);
		                },complete:function(XMLHttpRequest, textStatus){
		                	_self.ajaxComplete(XMLHttpRequest, textStatus);
		                }
		                */
			        });
					
				}
				
				//挂在树形子节点数据
				,mountChildData : function(fParent,index) {
//					console.log('fParent-->',fParent);
//					console.log('index-->',index);
//					var data = this.getChildData(fParent);
					this.getData(fParent,index);

				}				
				
				//装载数据到组件
				,loadData : function(data) {
//					console.log('loadData.参数-->',data);
					//data==''，代表是构建一个空的data结构
					if(data==''){
						this.rows = new Array();
						//构建一个空表
						var table = this.createTable();
//						this.userdata.relationAlias = table.userdata.relationAlias;
//						this.userdata.relationTypes = table.userdata.relationTypes;
						this.userdata['sys.count'] = 0;
//						this.userdata['sys.offset'] = 0;
					}else{
//						this.rows = data.rows;
						this.userdata.relationAlias = data.userdata.relationAlias;
						this.userdata.relationTypes = data.userdata.relationTypes;
						this.userdata['sys.count'] = data.userdata['sys.count'];
//						this.userdata['sys.offset'] = 0;
//						console.log('data-->',data);
						this.userdata.tableName = data.userdata.tableName;
						this.userdata.timestamp = data.userdata.timestamp;
						//初始化数据
						var newRows = this.initOriginalValue(data.rows);
//						console.log('-----------loadData.newRows-->',newRows);
						//数组合并
//						console.log('this.rows-->',this.rows);
//						console.log('newRows-->',newRows);
						//这种合并不行
//						this.rows.concat(newRows);
						//这种可以
						for(var i=0;i<newRows.length;i++){
							this.rows.push(newRows[i]);
						}
//						this.rows = newRows;
						if(this.aggregateColumns != null){
							this.aggregateValues = data.aggregateValues;
						}
						this.dataAccessPerm = data.dataAccessPerm;
					}
//					this.initOriginalValue();
					//初始化分页
					this.initPage();
					//设置索引
					if(this.rows.length>0){
						if(this.historyIndex!= null){
							this.setCurrentIndex(this.historyIndex);
							this.historyIndex = null;
						}else{
							this.setCurrentIndex(0);
						}
					}else{
						this.setCurrentIndex(null);
					}
					//this.userdata.recordState = 'none';
				}

				//装在页数据
				,loadPageData : function(pageIndex,append) {
					
					//刷新之前触发此事件	
					if(this.onBeforeRefresh){
						var event = {};
						event.source = this;
						event.cancel = false;
						this.onBeforeRefresh(event);
						if(event.cancel==true){
							return;
						}
					}
					
					if(pageIndex==undefined){
						pageIndex = this.currentPage;
					}

					//this.clearData();
					//如果append参数不存在，代表单独加载此页数据，需要清除原来的数据。
					//否则，代表追加，不清除原来的数据
					if(!append){
						this.clearData();
					}

					//修改当前页
					this.currentPage =  pageIndex ;
					//计算偏移量
					this.offset =  this.limit*(pageIndex - 1) ;
					
					this.getData();
//					this.loadData(this.getData())

				}
				
				
				/**
				name:bizData#onBeforeRefresh
				description: <b>[回调型事件]</b>业务数据刷新前
				@param {object} event 
				<br/><b>结构如下：</b>
				<xmp> 
				{
					"source" : 组件的js对象,
					"cancel" : 可修改，设置为true后中断当前刷新动作
				}
				</xmp>	
			    */
				/*
				//刷新数据之前调用
				,refreshBefore : function(event,callback) {
					if(callback){
						callback(event);
					}
					var deferred = $q.defer();
//					deferred.notify('About to greet ' + name + '.');
					if(event.cancel==true){
						//如果不成功，则直接返回
						deferred.reject('刷新之前事件参数被用户中断，不调用插入函数');
					}else{
						//如果成功，则调用插入函数
						deferred.resolve('刷新之前事件参数没有被用户中断，调用插入函数');
					}
					return deferred.promise;
				}
				*/
				//刷新数据，跳转到第一页
				,refreshData : function() {
					var _self = this;

					_self.firstPage();
//					console.log('BizData.refreshData!');
				}
				
				//刷新当前页
				,refreshPageData : function(pageIndex) {
					//初始化当前索引
					this.historyIndex = this.getCurrentIndex();
					
					if(pageIndex==undefined){
						pageIndex = this.currentPage;
					}
					
					this.loadPageData(pageIndex);
					
				}
				
				//加载更多（追加数据）
				,appendData : function() {
					/*
					if (this.currentPage < this.totalPage) {
					    var pageIndex = this.currentPage + 1;
//					    this.offset = this.offset + this.limit ;
//					    this.loadPageData(pageIndex);
						if(pageIndex==undefined){
							pageIndex = this.currentPage;
						}
	
//						this.clearData();
						//修改当前页
						this.currentPage =  pageIndex ;
						//计算偏移量
						this.offset =  this.limit*(pageIndex - 1) ;
						
						this.getData();
					}
					*/
					//随便设置任何参数，只要存在参数，就表示追加数据
					this.nextPage('anyParam');
				}
				
				
				//插入一行数据，前台数据插入
				,wrapRows : function(ids,defaultValues) {
					var _self = this;
					var rows = [];
					//执行前台插入动作（无初始值也要插入一行）
					for(var i=0;i<ids.length;i++){
						var row = {userdata: {recordState: 'new'}};
						row.userdata.changed=0;
						row.userdata.checked=false;
						row.userdata.recordID=ids[i];
						
						var values;
						if(defaultValues.length>0){
							values = defaultValues[i];
						}
						
						var defCols = _self.defCols;
						//循环列
						for(var column in defCols){
							var originalValue = null;
							var value = null;
							//默认赋值，如果存在默认值的话就赋值，否则也要循环列
							if(values){
								if(values[column]!='undefined'){
									originalValue = values[column];
									value = values[column];
								}
							}
							row[column] = {originalValue:originalValue,value:value,changed:0};
						}
						
						//设置
						row[_self.userdata.idColumnDefine].value = ids[i];
						row[_self.userdata.idColumnDefine].originalValue = ids[i];
						row.version.value = 0;
						row.version.originalValue = 0;
						//
						rows.push(row);
					}

					return rows;
				}
				
				//插入一行数据，前台数据插入
				,insert : function(index,row) {
					//console.log('values-->',values);
					var _self = this;
					
					//添加行之前触发此事件
					if(this.onBeforeNew){
						var event = {};
						event.source = this;
						event.cancel = false;
						this.onBeforeNew(event);
						if(event.cancel==true){
							return 'cancel';
						}
					}
				
					///////////////////////////////////////////////////////////////////////////////////
					//注销数据监视器
//					_self.deregRows();
//					_self.shutdownRowsWatcher();
					
					//插入动作
					//console.log('BizData.insert.index-->>',index);
					_self.rows.splice(index,0,row);
//					_self.recordState = 'new';
					
					//判断是否是树形
					if(_self.isTree){
						var parentRelation = _self.treeOption.parentRelation;
						var nodeKindRelation = _self.treeOption.nodeKindRelation;
						var fParent = row[parentRelation].value;
						if(fParent!=null){
							//设置父节点的节点类型
							var nodeKind = _self.getValue(nodeKindRelation,fParent);
							if(nodeKind!=null){
								_self.setValue(nodeKindRelation,null,fParent);
							}
						}
					}
					
					////////////////////////////////////////////////////////////////////////////////////
					
					//改变当前索引
					_self.setCurrentIndex(index);//this.rows.length - 1;
					
					var rowID = row[_self.userdata.idColumnDefine].value;
					//添加行之后触发此事件	
					if(_self.onAfterNew){
						var event = {};
						event.source = _self;
						//留下下面的这一行语句，是因为历史上一次newData只支持增加一行
						event.id = rowID;
						//event.data = data.data;
						_self.onAfterNew(event);
					}
					return rowID;
				}
				
				/*
				//新增两行数据到最后，并且给出sName和sCode的默认值
			     var data = justep.xbl('mainData');
			     var options = {
			         index : data.getCount(),
			         defaultValues : [
			             {sName:'a1',sCode:'b1'},
			             {sName:'a2',sCode:'b2'}
			         ]
			     };    
			     data.newData(options);
		 		*/
				
				/*
				 * 插入数据的设计原理是：
				 * 调用newData函数，对后台进行访问，获取系统信息后插入前台
				 * 目前可以考虑兼容之前的版本（没有访问后台的动作）
				*/
				//添加
				,newData : function(options) {
					//console.log('BizData.newData.options-->',options);
					var _self = this;
					
					//插入位置（默认插入最后一行）
					var index = _self.rows.length;
					//判断是否有参数传入
					//debugger;
					if(options){
						//有参数
						//是否输入index
						index = options.index;
						//console.log('BizData.newData.index-->>',index);
					}
					
					//判断是否有初始值
					var defaultValues = [];
					if(options && options.defaultValues){
						//有参数
						//console.log('newData.options.defaultValues-->>',options.defaultValues);
						/*
						//判断是否有初始值
						if(defaultValues.length==0){
							defaultValues = options.defaultValues;
						}else{
							//存在，合并数组
							defaultValues.concat(options.defaultValues);
						}
						*/
						defaultValues = options.defaultValues;
					}
					//console.log('newData.defaultValues-->>',defaultValues);

					//新建时增加的创建参数事件
					//可以在data组件的onNewCreateParam事件中，写代码设置默认值，代码如下
					/*
					mainActivity.dataMainNewCreateParam = function(event){
					    event.defaultValues.push({rowID: '值',关系标识: '值'});
					};
					*/
					
					var param = {};
					if(_self.onNewCreateParam){
						var event = {};
						event.source = _self;
						event.param = {};
						event.defaultValues = [];//defaultValues;
						//执行事件
						_self.onNewCreateParam(event);
						//console.log('newData.onNewCreateParam.event-->>',event);
						
						//取出参数
						param = event.param;
						//取出默认值
						if(defaultValues.length==0){
							defaultValues = event.defaultValues;
						}else{
							//存在，合并数组
							//concat()把两个或者多个数组链接在一起，但是不改变已经存在的数组
							//而是返回一个链接之后的新数组
							/*
							var a = [1,2,3];
							a.concat([4,5]);
							console.log(a);
							//此处输出为 [1, 2, 3]

							var a = [1,2,3];
							a = a.concat([4,5]);
							console.log(a);
							//此处输出为 [1, 2, 3 ,4 ,5]
							*/
							defaultValues = defaultValues.concat(event.defaultValues);
						}
					}
					//console.log('event-->',event);
					//新增行数
					var rowCount = 1;//默认增加1行
					if(defaultValues.length>1){
						rowCount = defaultValues.length
					}
					//加入参数
//					param.rowCount = rowCount;
					
					
					param.concept = this.concept;
					param.idColumnDefine = this.userdata.idColumnDefine;
//					param.defCols = this.defCols;
					param.defaultValues = defaultValues;
					param.offset = this.offset;
					
					
					
					
					//console.log('最终参数defaultValues.length-->>',defaultValues.length);
					if(!this.creater){alert('this.creater不能为空');return;}
					//调用后台插入函数
					$.LoadingOverlay("show");
					$.ajax({
			            type: "POST",
			            async : false,
			            url: this.creater,
//				        data: {"id":rowID},// "{}",
			            data: JSON.stringify(param),
			            contentType: "application/json; charset=utf-8",
			            dataType: "json",
				        //processData: false,
			            success: function (data,textStatus) {
							$.LoadingOverlay("hide");

			                // Play with returned data in JSON format
							console.log('newData.data-->',data);
							if(data.code==0){

								var ids = data.data.ids;//.split(",");
								
								var rows;
								//为了兼容前一版本
								//if(data.data['@type']=='table'){
									//后端装配数据行
									_self.userdata.relationAlias = data.data.userdata.relationAlias;
									_self.userdata.relationTypes = data.data.userdata.relationTypes;
									//增加原始值并且处理Decimal类型的数据
									rows = _self.initOriginalValue(data.data.rows);
								//}else{
									//alert('后台需要更新到最新版本的newData()');
									//前端装配数据行（要求前端必须定义defCols）
									//rows = _self.wrapRows(ids,defaultValues);
								//}
								
								ids = [];
								//执行前台插入动作（无初始值也要插入一行）
								for(var i=0;i<rows.length;i++){
									var rowID = _self.insert(index+i,rows[i]);
//									var id = row[_self.userdata.idColumnDefine].value;
									ids.push(rowID);
								}
								
								//使UI变为可编辑状态
								_self.editData();
								
								//添加行之后触发此事件	
								if(_self.onNewDataAfter){
									var event = {};
									event.source = _self;
									event.ids = ids;
									_self.onNewDataAfter(event);
								}

								console.log('newData.data-->ajax函数调用全部完成！');
								return ids;
							}else{
								alert('数据组件操作失败：'+data.msg+',错误代码：'+data.code);
							}
			            }
						/*
						,error: function(XMLHttpRequest, textStatus, errorThrown){
			            	_self.ajaxError(XMLHttpRequest, textStatus, errorThrown);
		                },complete:function(XMLHttpRequest, textStatus){
		                	_self.ajaxComplete(XMLHttpRequest, textStatus);
		                }
		                */
			        });
					
				}
				

				
				
				//////////////////删除功能区开始//////////////////////////////////////////
				
				//前端删除，需要保存,移除一行数据，只在前端移除，并且放入删除缓冲区不影响数据库
				,removeDataByIndex : function(index){
					if(index!= null ){
						var row = this.rows[index];
						//如果不是新增状态，则放进删除缓冲区，否则直接删除
						if(row.userdata.recordState != 'new'){
							row.userdata.recordState = 'delete';
							this.deleterows.push(row);
						}
						this.rows.splice(index,1);
						//重新设置表的行数
//						this.userdata['sys.count']=this.userdata['sys.count'] - 1;
					}
				}
				
				//删除，需要保存,移除一行数据，只在前端移除不影响数据库
				,removeChildDataByID : function(rowID){
					//树形
					//获取fParent
					var nodeKindRelation = this.treeOption.nodeKindRelation;
					var nodeKind = this.getValue(nodeKindRelation,rowID);
					//删除子节点（如果有）
					//获取子节点
					var children = this.getChildren(rowID);
//						console.log('children-->',children);
					for (var j=children.length - 1;j>=0 ;j-- ){
						//前台移除数据，需要保存动作才能持久化
						var id = children[j][this.userdata.idColumnDefine].value;
						var index = this.getIndex(id);
						//console.log('index-->',index);
						if(this.directDeleteMode==true){
							//直接删除（先删除后端数据库，再无状态删除前端data）
							//无需放入删除缓冲区
							this.rows.splice(index,1);
						}else{
							//放入删除缓冲区
							this.removeDataByIndex(index);
						}
					}
					
				}

				//树形重新排序号（输入参数为节点ID，影响当前及子节点）
				,sortingNode : function(rowID){
					var fParent = rowID;
					var childs = this.getChilds(fParent);
					var childCount = childs.length;
					if(childCount>0){
						for(var i=0;i<childCount;i++){
							var nodeSortRelation = this.treeOption.nodeSortRelation;
							
							//首先获取父序号
							var parentSortNo = "";
							if(fParent!=null){
								parentSortNo = this.getValue(nodeSortRelation,fParent);
							}
							//计算本级序号
							var newSortNo = "/" + this.preZeroFill(i + 1,3);
							newSortNo = parentSortNo + newSortNo;
							//获取本级序号
							var oldSortNo = childs[i][nodeSortRelation].value;
							//比较之后进行更新
							if(oldSortNo!=newSortNo){
								//更改为最新序号
								childs[i][nodeSortRelation].value = newSortNo;
								
								//被更改的节点如果存在子节点
								var children = this.getChilds(rowID);
								if(children.length>0){
									var childID = childs[i][this.userdata.idColumnDefine].value;
									this.sortingNode(childID);
								}
							}
						}
					}
				}
				
				//删除，需要保存,移除一行数据，只在前端移除不影响数据库
				,removeDataByID : function(rowID){
					var _self = this;
					//删除之前判断是否是树形（首先删除子节点）
					var parentRelation = this.treeOption.parentRelation;
					var fParent = null;
					if(this.isTree){
						fParent = this.getValue(parentRelation,rowID);
						_self.removeChildDataByID(rowID);
						//查看是否将子节点也同时放进了删除缓冲区
						//console.log('_self.deleterows-->>',_self.deleterows);
						//console.log('_self.rows-->>',_self.rows);
					}
					//前台移除数据，需要保存动作才能持久化
					var index = this.getIndex(rowID);
					if(this.directDeleteMode==true){
						//直接删除（先删除后端数据库，再无状态删除前端data）
						//无需放入删除缓冲区
						this.rows.splice(index,1);
					}else{
						//放入删除缓冲区
						this.removeDataByIndex(index);
					}
					
					//设置删除后的新索引
					if(this.isTree){

						//处理父节点类型
						var nodeKindRelation = this.treeOption.nodeKindRelation;
						
//						console.log('nodeKindRelation-->',nodeKindRelation);
//						console.log('fParent-->',fParent);

						//获取兄弟数量，如果兄弟的数量小于等于0，则将当前索引设置为父亲的索引
						var childs = this.getChilds(fParent);
						var childCount = childs.length;
//						console.log('childs-->',childs);
						if(childCount==0){
							//如果兄弟节点数量为0，则将父节点的类型设置为叶子，且无需处理序号
							this.setValue(nodeKindRelation,'nkLeaf',fParent);
							
							var index = this.getIndex(fParent)
							this.setCurrentIndex(index);
							
						}else{
							//无需处理节点类型
							//处理当前索引
							//在当前行删除之后还有兄弟节点，将当前索引设置为当前或者最后一个
							var childMaxID = childs[childCount - 1][this.userdata.idColumnDefine].value;
							var childMaxIndex = this.getIndex(childMaxID);
							var currentIndex = index;//this.getCurrentIndex();

							if(currentIndex>childMaxIndex){
								//如果当前索引值大于兄弟节点的最大索引值，则将当前索引值设为兄弟节点的最大索引值
								//获取最大的兄弟节点
								this.setCurrentIndex(childMaxIndex);
							}else{
								//索引值不变，但是触发当前ID变化
//								this.setCurrentID(this.rows[index][this.userdata.idColumnDefine].value);
								this.setCurrentIndex(currentIndex);
								
								//处理兄弟节点的排序号（只有这种情况下才需要处理）
								this.sortingNode(fParent);
							}							
						}
					}else{
						//设置新的index（表格）
						if(this.rows.length<=0){
							//如果行数小于等于0，则将当前索引值设为-1
							this.setCurrentIndex(null);
						}else if(this.getCurrentIndex()>this.rows.length - 1){
							//如果当前索引值大于行数，则将当前索引值设为行数
							this.setCurrentIndex(this.rows.length - 1);
						}else{
							//索引值不变，但是触发当前ID变化
//							this.setCurrentID(this.rows[index][this.userdata.idColumnDefine].value);
							this.setCurrentIndex(index);
						}
					}
//					console.log('this.getCurrentIndex()-->',this.getCurrentIndex());
				}
				//删除前端data中的数据
				,removeDataByIDs : function(arrayIDs){
					var _self = this;
					//循环调用移除函数
					for (var i=0;i<arrayIDs.length ;i++ ){
						//调用移除函数
						_self.removeDataByID(arrayIDs[i]);
					}
					//_self.recordState = 'delete';

					//删除行之后触发此事件	
					if(_self.onAfterDelete){
						var event = {};
						event.source = _self;
//							event.cancel = false;
						event.deleteIDList = arrayIDs;
						_self.onAfterDelete(event);
					}
					
				}
				
				/**
				name:bizData#onBeforeDelete
				description: <b>[回调型事件]</b>业务数据删除前
				@param {object} event 它的结构如下:<br/>
				{
					"source":组件的js对象
					,"cancel":可修改	，设置为true后中断当前delete动作
					,"deleteIDList":删除的行Id数组
				}
				*/
				
				//这是主要删除函数
				/*
				 * 这里要强调的是删除缓冲区，即（this.deleterows） *****************
				 * 前端删除行后会放到删除缓冲区中，待到save时提交到后端数据库删除
				 * 后端删除行会首先执行数据库删除，成功返回后再将前端data中的行无状态删除，
				 * 并不放到删除缓冲区中，并将让监视器不因此影响data的状态，这很重要
				 */
				//前端删除，需要保存,移除数据，只在前端移除不影响数据库
				,removeData : function(rowIDs){
					
					var _self = this;
					
					if(this.deleteConfirm){
						var r=confirm("确定要删除吗？");
						if (r==false){
							return -1;
						}
					}
					
					//将参数转换成数组
					var arrayIDs= new Array();   
					if(angular.isArray(rowIDs)){
						arrayIDs = rowIDs;
					}else{
						//字符串转成数组
						arrayIDs=rowIDs.split(",");
					}
					
					//删除行之前触发此事件	
					if(this.onBeforeDelete){
						var event = {};
						event.source = this;
						event.cancel = false;
						event.deleteIDList = arrayIDs;
						this.onBeforeDelete(event);
						if(event.cancel==true){
							return;
						}
					}
					
					//调用删除函数
					if(this.directDeleteMode==true){
						//调用后端删除函数
						_self.deleteDataByID(arrayIDs);
					}else{
						//调用前端删除函数
						_self.removeDataByIDs(arrayIDs);
					}

				}
				
				//后端删除。业务数据删除方法，当directDeleteMode=true时直接提交后台删除，当deleteConfirm=true时会弹出删除确认框
				,deleteDataByID : function(arrayIDs){
					var _self = this;
					$.ajax({
			            type: "POST",
			            async : false,
			            url: this.deleter,
//			            data: {"id":rowID},// "{}",
			            data: JSON.stringify({"ids":arrayIDs}),// "{}",
			            contentType: "application/json; charset=utf-8",
			            dataType: "json",
//			            processData: false,
			            success: function (data,textStatus) {
			                // Play with returned data in JSON format
			            	console.log('deleteDataByID.success.data-->>',data);
			            	if(data.code==0){
				            	//调用前端删除函数
								_self.removeDataByIDs(arrayIDs);
			            	}else{
			            		alert("后端删除函数调用失败："+data.msg+',错误代码：'+data.code);
			            	}
			            	
			            }
						/*
						,error: function(XMLHttpRequest, textStatus, errorThrown){
			            	_self.ajaxError(XMLHttpRequest, textStatus, errorThrown);
		                },complete:function(XMLHttpRequest, textStatus){
		                	_self.ajaxComplete(XMLHttpRequest, textStatus);
		                }
		                */
			        });
					return 0;
				}
				
				//下面的函数可以做为BizData对外暴露的函数使用，
				//不管this.directDeleteMode为何值均直接删除，对内无用处
				,deleteData : function(rowIDs){
					var _self = this;
					if(this.deleteConfirm){
						var r=confirm("确定要删除吗？");
						if (r==false){
							return -1;
						}
					}
					//将参数转换成数组
					var arrayIDs= new Array();   
					if(angular.isArray(rowIDs)){
						arrayIDs = rowIDs;
					}else{
						//字符串转成数组
						arrayIDs=rowIDs.split(",");
					}
					//删除行之前触发此事件	
					if(this.onBeforeDelete){
						var event = {};
						event.source = this;
						event.cancel = false;
						event.deleteIDList = arrayIDs;
						this.onBeforeDelete(event);
						if(event.cancel==true){
							return;
						}
					}
					var directDeleteMode = this.directDeleteMode;
					this.directDeleteMode = true;
					//一次传入多个id予以删除
					_self.deleteDataByID(arrayIDs);
					this.directDeleteMode = directDeleteMode;
				}
				

				//////////////////删除功能区结束//////////////////////////////////////////
				
				
				//查询
				,queryData : function(event) {
					//设置条件查询条件
					this.filters = [{"name":"filter1","filter":"sss"},{"name":"filter2","filter":"sss2"}];
					this.refreshData();
				}
				
				//构建空表
				,createTable : function(){
					var table = new Object();//{};
//					table["@type"] = "table";
					table.concept = this.concept;
					table.rows = new Array();
					table.deleterows = new Array();
					table.userdata = {};
					//增加id列的相关属性
					table.userdata.idColumnDefine =this.userdata.idColumnDefine;
					table.userdata.idColumnName =this.userdata.idColumnName;
					table.userdata.idColumnType =this.userdata.idColumnType;
					table.userdata.model =this.userdata.model;
					table.userdata.updateMode =this.userdata.updateMode;
					table.userdata.changed =0;
					table.userdata.tableName = this.concept;
					
					table.userdata['sys.count'] = 0;
					table.userdata['sys.offset'] = 0;
					return table;
				}
				
				//修改
				,editData : function() {
					this.userdata.recordState = 'edit';
					//判断是否有从表
					var slaveDatas = this.slaveDatas;
			    	//console.log('this.slaveDatas-->>',this.slaveDatas);
					if(slaveDatas.length>0){
						//存在从表,需要调用从表的数据打包函数
						//遍历从data
					    for(var i=0;i<slaveDatas.length;i++){
					    	//console.log('打开从表可编辑状态！');
					    	this.container[slaveDatas[i]].userdata.recordState = 'edit';
					    }
					}
				}
				
				//取消修改
				,editCancel : function() {
					//处理数据
					if(this.userdata.recordState == 'new'){
						this.loadPageData();
					}else{
						this.refreshPageData();
					}
					
					//处理UI
					this.userdata.recordState = 'none';
					//判断是否有从表
					var slaveDatas = this.slaveDatas;
					if(slaveDatas.length>0){
						//存在从表,需要调用从表的数据打包函数
						//遍历从data
					    for(var i=0;i<slaveDatas.length;i++){
					    	this.container[slaveDatas[i]].userdata.recordState = 'none';
					    }
					}
				}
				//数据录入过程中对当前行数据进行数据有效性验证，将影响保存动作
				//需要用户在UI中触发（如：绑定ng-change事件进行调用）
				,validData : function(rowIndex, col) {
					var _self = this;
					var options = {};
					options.rowIndex = rowIndex;
					options.column = col;
					options.row = _self.rows[rowIndex];
					
					$.LoadingOverlay("show");
					$.ajax({
			            type: "POST",
			            async : true, //同步
			            url: this.valider,
//			            data: {"id":rowID},// "{}",
			            data: JSON.stringify(options),// "{}",
			            contentType: "application/json; charset=utf-8",
			            dataType: "json",
//			            processData: false,
			            success: function (data,textStatus) {
							$.LoadingOverlay("hide");
			                // Play with returned data in JSON format
			            	//console.log('validData.success.data-->>',data);
			            	if(data.code==0){
								//设置列
			            		_self.rows[rowIndex][col].invalid = data.data.invalid;
			            		
								var invalid = 0;
								//循环每一列
								for(var column in _self.rows[rowIndex]){
									//console.log('column：'+column);
									if(column.indexOf('$$')== -1 && column!='userdata' && column!='version'
									){
										if(_self.rows[rowIndex][column].invalid){
											invalid = invalid + _self.rows[rowIndex][column].invalid;
										}
									}
								}
								//设置行
								_self.rows[rowIndex].userdata.invalid = invalid;
								//console.log('_self.rows[rowIndex]-->>',_self.rows[rowIndex]);
			            	}else{
			            		alert("数据有效性验证函数调用错误："+data.msg+',错误代码：'+data.code);
			            	}
			            }
						/*
						,error: function(XMLHttpRequest, textStatus, errorThrown){
			            	_self.ajaxError(XMLHttpRequest, textStatus, errorThrown);
		                },complete:function(XMLHttpRequest, textStatus){
		                	_self.ajaxComplete(XMLHttpRequest, textStatus);
		                }
		                */
			        });
					
				}
				
				//保存之前，打包数据
				,saveBefore : function() {
					var _self = this;
					
					/**
					name:bizData#onBeforeSave
					description: <b>[回调型事件]</b>业务数据保存前，事件在批事务启动后触发，写在这个事件里的biz action请求将在一个批操作完成
					@param {object} event 
					<br/><b>结构如下：</b>
					<xmp> 
					{
						"source" : 组件的js对象,
						"cancel" : 可修改，设置为true后中断当前保存动作
					}
					</xmp>	
					*/
					//刷新之前触发此事件	
					if(this.onBeforeSave){
						var event = {};
						event.source = this;
						event.cancel = false;
						this.onBeforeSave(event);
						if(event.cancel==true){
							return null;
						}
					}

					//保存前需要整理数据
					var table = this.createTable();
					
//					console.log('打包前table-->',table);
//					console.log('打包前table.rows.length-->',table.rows.length);
					
					//循环rows
					for(var i=0;i<this.rows.length;i++){
						var row = this.rows[i];
						var recordState = row.userdata.recordState;
						switch(recordState){
						case 'new':
							//放入待保存数据中
							table.rows.push(row);
							break;
						case 'edit':
							//放入待保存数据中
							table.rows.push(row);
							break;
						/*	
						case 'delete':
							//放入待保存数据中
							table.rows.push(row);
							break;
						*/	
						case 'none':
							//放入待保存数据中，测试使用
							//table.rows.push(row);
							break;
						default:
								
						}
					}
					//循环deleterows
					for(var i=0;i<this.deleterows.length;i++){
						//放入待保存数据中
						//var row = this.deleterows[i];
						//table.rows.push(row);
						table.rows.push(this.deleterows[i]);
						
					}
					
					//遍历每一行，每一列
					for(var i=0;i<table.rows.length;i++){
						//放入待保存数据中
						var row = table.rows[i];
						//判断是否存在不合法数据
						if(row.userdata.invalid>0){
							alert('存在不合法数据，无法保存！');
							return null;
						}
//						console.log('行：'+i);
						//每一列
//						for(var column in this.defCols){
//							var type = this.defCols[column].type;
//						var columns = this.userdata.relationAlias.split(",");
//						var types = this.userdata.relationTypes.split(",");
//						for(var i=0;i<columns.length;i++){
						var invalidCount = 0;
						for(var column in row){
							//console.log('column：'+column);
							if(column.indexOf('$$')== -1 && column!='userdata'/* && column!='version'*/
							){
								if(column=='enterpriseNo'){
									if(!row[column].value){
										alert('调试使用：enterpriseNo为空，不能保存！')
										return null;
									}
								}
	
								//var column = columns[i];
								var type = row[column].type;//types[i];
								//console.log('row[column].type：'+row[column].type);
								//转化为浮点数
								if(type=='Decimal'){
									if(isNaN(row[column].value)){
										//不是数字
										//alert('列：'+column+'-->'+'列类型：'+type+'-->值：'+row[column].value+'[不是数字，无法保存]');
										//return null;
										invalidCount++;
										console.log('列：'+column+'-->'+'列类型：'+type+'-->值：'+row[column].value+'[不是数字，无法保存]');
									}
								}
								//转化为整数
								if(type=='Integer'){
									if(isNaN(row[column].value)){
										//不是数字
										//alert('列：'+column+'-->'+'列类型：'+type+'-->值：'+row[column].value+'[不是数字，无法保存]');
										//return null;
										invalidCount++;
										console.log('列：'+column+'-->'+'列类型：'+type+'-->值：'+row[column].value+'[不是数字，无法保存]');
									}
								}
								//转化为日期
								//后台可以接收日期值为null，但是不可以接收''
								//前台可以接收日期值为''，但是不可以接收null
								if(type=='Date' || type=='DateTime' || type=='String'){
									if(!row[column].value){
										row[column].value = null;
										//row[column].changed = 0;
									}
									if(!row[column].originalValue){
										row[column].originalValue = null;
									}
									/*
									if(type=='Date' || type=='DateTime'){
										console.log('调试：'+column+'-->>'+row[column].value);
									}
									*/
								}
							}
						}
						if(invalidCount>0){
							console.log('表名：'+this.concept);
							alert('存在不是数字的列，无法保存！');
							return null;
						}
						
					}
					
					//删除$$hashKey
					/*
					var result = angular.copy(this.data);
					var rows = result.rows;
					for(var i=0;i<rows.length;i++){
						delete rows[i].$$hashKey;
					}
					*/
					
					/*
					var defCols = this.defCols;
					var relationAliasArray=new Array();
					var relationTypesArray=new Array();
					for(var column in defCols){
						relationAliasArray.push(defCols[column].name);
						relationTypesArray.push(defCols[column].type);
					}
					var relationAlias = relationAliasArray.join(',');
					var relationTypes = relationTypesArray.join(',');
					table.userdata.relationAlias = relationAlias;
					table.userdata.relationTypes = relationTypes;
					*/

					table.userdata.relationAlias = this.userdata.relationAlias;
					table.userdata.relationTypes = this.userdata.relationTypes;

					table.slaves = [];
					//判断是否有从表
					var slaveDatas = this.slaveDatas;
					if(slaveDatas.length>0){
						//存在从表,需要调用从表的数据打包函数
						//遍历从data
					    for(var i=0;i<slaveDatas.length;i++){
//					    	console.log('this.container[slaveDatas[i]]-->',this.container[slaveDatas[i]]);
					    	var slaveTable = this.container[slaveDatas[i]].saveBefore();
					    	if(slaveTable==null){
					    		return null;
					    	}
					    	table.slaves.push(slaveTable);
					    }
					}
					
					return table;
				}
				
				//保存
				,saveData : function() {
					var _self = this;

					var table = this.saveBefore();
					//console.log('preSaveTable-->',table);
					
//					console.log('打包后table-->',table);
					
//					if(table==null || table.rows.length<=0){
					if(table==null){
						return 0;
					}
					
//					$.LoadingOverlay("show");
					
					//提交保存
//					var response = this.dataService.save(table);
					/*
					data:要求为Object或String类型的参数，发送到服务器的数据。如果已经不是字符串
					，将自动转换为字符串格式。get请求中将附加在url后。防止这种自动转换
					，可以查看　　processData选项。对象必须为key/value格式
					，例如{foo1:"bar1",foo2:"bar2"}转换为&foo1=bar1&foo2=bar2。如果是数组
					，JQuery将自动为不同值对应同一个名称。
					例如{foo:["bar1","bar2"]}转换为&foo=bar1&foo=bar2。
					*/
//					console.log('table-->',table);
					$.ajax({
			            type: "POST",
			            async : false,//同步执行，异步执行时angularjs需要调用$apply()才能更新UI
			            url: this.writer,
			            data: JSON.stringify(table),// "{}",
			            contentType: "application/json; charset=utf-8",
			            dataType: "json",
//			            processData: false,
			            success: function (data, textStatus) {
			                // Play with returned data in JSON format
							console.log('saveData.success.data-->',data);
//							$.LoadingOverlay("hide");
						
							if(data.code==0){
								_self.saveAfter(data.data);
							}else{
								alert("数据保存函数调用错误："+data.msg+',错误代码：'+data.code);
							}

							//console.log('_self-->>',_self);
							return 0;
			            }
						/*
						,error: function(XMLHttpRequest, textStatus, errorThrown){
			            	_self.ajaxError(XMLHttpRequest, textStatus, errorThrown);
		                },complete:function(XMLHttpRequest, textStatus){
		                	_self.ajaxComplete(XMLHttpRequest, textStatus);
		                }
		                */
			        });
				}
				
				//保存之后，清除recordState状态值
				,saveAfter : function(data) {
					var _self = this;
					console.log('saveAfter.data-->>',data);
					var count = this.rows.length;
					if(count>0){
						for(var i=count - 1;i>=0;i--){
							var state = _self.rows[i].userdata.recordState;
							if(state=='delete'){
								//这个已经取消，转为设置单独缓冲区
//								_self.rows.splice(i,1);
							}else if(state=='new' || state=='edit'){
								if(state=='edit'){
									/*
									if(data.rows){
										//兼容老版本
										//刷新版本
										for(var x=0;x<data.rows.length;x++){
											if(_self.rows[i][_self.userdata.idColumnDefine].value==data.rows[x].id){
												_self.rows[i].version.value = data.rows[x].version;
											}
										}
									}else{
										//版本+1（虽然是编辑状态，但是不一定就有数据改变）
										if(_self.rows[i].userdata.changed>0){
											_self.rows[i].version.value++;
										}
									}
									*/
									//版本+1（虽然是编辑状态，但是不一定就有数据改变）
									if(_self.rows[i].userdata.changed>0){
										_self.rows[i].version.value++;
									}
								}
								
								//将原值与新值统一
								_self.initRowOriginalValue(_self.rows[i]);
								_self.rows[i].userdata.recordState = 'none';
							}
						}
					}
					
					if(_self.deleterows.length>0){
						_self.deleterows = new Array();
					}
					
					_self.userdata.recordState = 'none';
					_self.userdata.changed = 0;
					
					//放在这里才能保证子表的事件被触发
					/**
					name:bizData#onAfterSave
					description: <b>[回调型事件]</b>业务数据保存后，事件在批事务启动后触发，写在这个事件里的biz action请求将在一个批操作完成
					@param {object} event 
					<br/><b>结构如下：</b>
					<xmp> 
					{
						"source" : 组件的js对象
					}
					</xmp>	
					 */
					
					//添加行之后触发此事件	
					if(_self.onAfterSave){
						var event = {};
						event.source = _self;
						_self.onAfterSave(event);
					}
					
					//判断是否有从表
					var slaveDatas = _self.slaveDatas;
					if(slaveDatas.length>0){
						//存在从表,需要调用从表的刷新函数
						//遍历从data
					    for(var i=0;i<slaveDatas.length;i++){
				    		//从表名称
				    		console.log('从表名称-->>',_self.container[slaveDatas[i]].concept);
					    	/*
				    		if(data && data.slaves){
					    		//根据从表名称处理
					    		for(var i=0;i<data.slaves.length;i++){
					    			if(_self.container[slaveDatas[i]].concept==data.slaves[i].concept){
					    				//找到相同表名的数据
								    	_self.container[slaveDatas[i]].saveAfter(data.slaves[i]);
					    			}
					    		}
					    	}else{
					    		//为了兼容老版本
						    	_self.container[slaveDatas[i]].saveAfter();
					    	}
					    	*/
				    		//根据从表名称处理
				    		for(var i=0;i<data.slaves.length;i++){
				    			if(_self.container[slaveDatas[i]].concept==data.slaves[i].concept){
				    				//找到相同表名的数据
							    	_self.container[slaveDatas[i]].saveAfter(data.slaves[i]);
				    			}
				    		}
				    		
					    }
					}
				}
				
				
				
				
				
				
				
				/////////////////////树形组件开始//////////////////////////////////////
				//是否叶子
				,isLeaf : function(row){
					return row[this.treeOption.nodeKindRelation].value=='nkLeaf'; 
				}
				//根节点数组
				,getRoots : function(){
					var children = [];
					var rows = this.rows;
					for(var i=0;i<rows.length;i++){
						var row = rows[i];
						if(row[this.treeOption.parentRelation].value==null || row[this.treeOption.parentRelation].value==''){
							children.push(row);
						}
					}
					return children; 
				}
				//根节点数组ids
				,getRootsIDs : function(){
					var ids = [];
					var rows = this.rows;
					for(var i=0;i<rows.length;i++){
						var row = rows[i];
						if(row[this.treeOption.parentRelation].value==null || row[this.treeOption.parentRelation].value==''){
							ids.push(row[this.userdata.idColumnDefine].value);
						}
					}
					return ids; 
				}
				//子节点数组
				//参数remove是否包含已经设置删除标志的项目//false：不包含，true：包含（默认值：true）
				,getChilds : function(rowID){
					var children = [];
					var rows = this.rows;
					for(var i=0;i<rows.length;i++){
						var row = rows[i];
						if(row[this.treeOption.parentRelation].value==rowID){
							children.push(row);
						}
					}
					return children; 
				}
				//子节点数组ids
				//参数remove是否包含已经设置删除标志的项目//false：不包含，true：包含（默认值：true）
				,getChildsIDs : function(rowID){
					var ids = [];
					var rows = this.rows;
					for(var i=0;i<rows.length;i++){
						var row = rows[i];
						if(row[this.treeOption.parentRelation].value==rowID){
							ids.push(row[this.userdata.idColumnDefine].value);
						}
					}
					return ids; 
				}
				//子孙后代节点数组
				,getChildren : function(rowID){
					var children = [];
					var rows = this.rows;
					for(var i=0;i<rows.length;i++){
						var row = rows[i];
						if(row[this.treeOption.pathRelation].value.indexOf(rowID)!= -1 && row[this.userdata.idColumnDefine].value!=rowID){
							children.push(row);
						}
					}
					return children; 
				}
				//子孙后代节点数组ids
				,getChildrenIDs : function(rowID){
					var ids = [];
					var rows = this.rows;
					for(var i=0;i<rows.length;i++){
						var row = rows[i];
						if(row[this.treeOption.pathRelation].value.indexOf(rowID)!= -1 && row[this.userdata.idColumnDefine].value!=rowID){
							ids.push(row[this.userdata.idColumnDefine].value);
						}
					}
					return ids; 
				}
				//展开（同时修改展开状态）
				,expandRow : function(rowID) {
					var index = this.getIndex(rowID);
					if(index==null)return;
					
					this.rows[index].$$isExpand = true;
					this.expand(rowID);
//					this.setCurrentIndex(index);
					//如果上级节点没有展开，则需要展开上级节点
					var parent = this.getValue(this.treeOption.parentRelation,rowID);
					if(parent!=null){
						this.expandRow(parent);
					}
				}
				//展开
				,expand : function(rowID) {
//					var index = this.getIndex(rowID);
//					if(index==null)return;
//					 
//					 //挂载子节点数据
//					 var row = this.rows[index];
//					 if(this.treeOption.rootFilter!='' && row.$$isMounted!=true){
//						 this.mountChildData(rowID,index);
//						 //标记当前行已挂载
//						 row.$$isMounted=true;
//					 }
//					 console.log('$scope.treeData-->',$scope.treeData);

					 var children = this.getChilds(rowID);
					 for(var i=0;i<children.length;i++){
					 	 children[i].$$isVisible = true;
					 }
				}
				//折叠（同时修改折叠状态）
				,collapseRow : function(rowID) {
					var index = this.getIndex(rowID);
					this.rows[index].$$isExpand = false;
					this.collapse(rowID);
				}
				//折叠
				,collapse : function(rowID) {
					 var children = this.getChilds(rowID);
					 for(var i=0;i<children.length;i++){
						 children[i].$$isVisible = false;
						 //关闭孩子的孩子
						 if(children[i].$$isExpand==true){
							 children[i].$$isExpand=false;
							 this.collapse(children[i][this.userdata.idColumnDefine].value);
						 }
					 }
				}
				//切换
				,itemExpanded : function(row,$event){
					if(this.isLeaf(row)){return;}

					if(row.$$isExpand == true){
						this.collapse(row[this.userdata.idColumnDefine].value);
					}else{
						this.expand(row[this.userdata.idColumnDefine].value);
					}
					row.$$isExpand = !row.$$isExpand;
					$event.stopPropagation();
				}
				//checked
				,itemChecked : function(row,$event){
					
					row.userdata.checked=!row.userdata.checked;
					this.check(row,row.userdata.checked);
					$event.stopPropagation();
				}
				//选中或者不选（处理子节点和兄弟节点）
				,check : function(row,value) {
					row.userdata.checked = value;
					var rowID = row[this.userdata.idColumnDefine].value;
					//处理子节点
					 var children = this.getChilds(rowID);
					 for(var i=0;i<children.length;i++){
						 this.check(children[i],value);

					 }
					//处理兄弟节点全部被选中之后，或者是全部不被选中之后
					 
				}
				
				//////////////////////树形组件结束////////////////////////////////////////
				//行点击事件
				,onRowClick : function(row,$event){
					//设置当前行索引和id
					var rowIndex = this.rows.indexOf(row);
					this.setCurrentIndex(rowIndex);
				}
				//行双击事件
				,onRowDblClick : function(row,$event){
//					if(this.isTree){
//						this.itemExpanded(row,$event);
//					}
				}
				
				/////////////////////////////////////////////////////////////////////////////////////
				/////////////////////////////////////////////////////////////////////////////////////
				
				,guid : function() {
				    var guid = "";
				    for (var i = 1; i <= 32; i++){
				      var n = Math.floor(Math.random()*16.0).toString(16);
				      guid +=   n;
				      /*
				      if((i==8)||(i==12)||(i==16)||(i==20))
				        guid += "-";
				      */
				    }
				    return guid;    
				}

				,preZeroFill : function(num, size) {
				    if (num >= Math.pow(10, size)) { //如果num本身位数不小于size位
				        return num.toString();
				    } else {
				        var _str = Array(size + 1).join('0') + num;
				        return _str.slice(_str.length - size);
				    }
				}

				
				/**
				 ** 加法函数，用来得到精确的加法结果
				 ** 说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
				 ** 调用：accAdd(arg1,arg2)
				 ** 返回值：arg1加上arg2的精确结果
				 **/
				,accAdd : function(arg1, arg2) {
				    var r1, r2, m, c;
				    try {
				        r1 = arg1.toString().split(".")[1].length;
				    }
				    catch (e) {
				        r1 = 0;
				    }
				    try {
				        r2 = arg2.toString().split(".")[1].length;
				    }
				    catch (e) {
				        r2 = 0;
				    }
				    c = Math.abs(r1 - r2);
				    m = Math.pow(10, Math.max(r1, r2));
				    if (c > 0) {
				        var cm = Math.pow(10, c);
				        if (r1 > r2) {
				            arg1 = Number(arg1.toString().replace(".", ""));
				            arg2 = Number(arg2.toString().replace(".", "")) * cm;
				        } else {
				            arg1 = Number(arg1.toString().replace(".", "")) * cm;
				            arg2 = Number(arg2.toString().replace(".", ""));
				        }
				    } else {
				        arg1 = Number(arg1.toString().replace(".", ""));
				        arg2 = Number(arg2.toString().replace(".", ""));
				    }
				    return (arg1 + arg2) / m;
				}

				
				
    			,walk:function()  
    			{  
    				console.log("walk,walk");  
    			}		
				
				,init:function(){
					console.log('BizData组件初始化函数！')
				}
    			
    		};
    	
    	//BizData.init();
		return BizData;
		
	};
	
//  services.factory('BizData',bizDataService);
	angular.module('app.BizData', []).factory('BizData',bizDataService);
//	angular.module('app.BizData', []).factory('BizData',['$rootScope',bizDataService]);
	
    
})